From 77ead0ba5f91ad6fd04fca1ab1e2b6847bf88136 Mon Sep 17 00:00:00 2001 From: tpearson Date: Sat, 7 Aug 2010 19:25:16 +0000 Subject: Yet more Qt4 API extensions... git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/dependencies/tqtinterface@1160323 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- qtinterface/tqt4/Qt/qapplication.h | 3 + qtinterface/tqt4/Qt/qdir.h | 266 ++++++++++++ qtinterface/tqt4/Qt/qlist.h | 17 +- qtinterface/tqt4/Qt/qmenu.h | 429 ++++++++++++++++++++ qtinterface/tqt4/Qt/qpixmap.h | 1 + qtinterface/tqt4/Qt/qtooltip.h | 87 ++++ qtinterface/tqt4/Qt/qvector.h | 802 +++++++++++++++++++++++++++++++++++++ qtinterface/tqt4/Qt/qwidget.h | 1 + 8 files changed, 1601 insertions(+), 5 deletions(-) create mode 100644 qtinterface/tqt4/Qt/qdir.h create mode 100644 qtinterface/tqt4/Qt/qmenu.h create mode 100644 qtinterface/tqt4/Qt/qtooltip.h create mode 100644 qtinterface/tqt4/Qt/qvector.h (limited to 'qtinterface/tqt4') diff --git a/qtinterface/tqt4/Qt/qapplication.h b/qtinterface/tqt4/Qt/qapplication.h index a9c22bb..d436c2d 100644 --- a/qtinterface/tqt4/Qt/qapplication.h +++ b/qtinterface/tqt4/Qt/qapplication.h @@ -118,6 +118,9 @@ class Q_GUI_EXPORT QApplication : public QCoreApplication public: enum Type { Tty, GuiClient, GuiServer }; + void installTranslator( QTranslator * ); + void removeTranslator( QTranslator * ); + #ifdef Q_WS_S60 typedef CApaApplication * (*QS60MainApplicationFactory)(); #endif diff --git a/qtinterface/tqt4/Qt/qdir.h b/qtinterface/tqt4/Qt/qdir.h new file mode 100644 index 0000000..e2248e1 --- /dev/null +++ b/qtinterface/tqt4/Qt/qdir.h @@ -0,0 +1,266 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial Usage +** Licensees holding valid Qt Commercial licenses may use this file in +** accordance with the Qt Commercial License Agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Nokia. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QDIR_H +#define QDIR_H + +#include +#include +#include +#include + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Core) + +class QDirPrivate; + +class Q_CORE_EXPORT QDir +{ +protected: + QScopedPointer d_ptr; +private: + Q_DECLARE_PRIVATE(QDir) +public: + enum Filter { Dirs = 0x001, + Files = 0x002, + Drives = 0x004, + NoSymLinks = 0x008, + AllEntries = Dirs | Files | Drives, + TypeMask = 0x00f, +#ifdef QT3_SUPPORT + All = AllEntries, +#endif + + Readable = 0x010, + Writable = 0x020, + Executable = 0x040, + PermissionMask = 0x070, +#ifdef QT3_SUPPORT + RWEMask = 0x070, +#endif + + Modified = 0x080, + Hidden = 0x100, + System = 0x200, + + AccessMask = 0x3F0, + + AllDirs = 0x400, + CaseSensitive = 0x800, + NoDotAndDotDot = 0x1000, + + NoFilter = -1 +#ifdef QT3_SUPPORT + ,DefaultFilter = NoFilter +#endif + }; + Q_DECLARE_FLAGS(Filters, Filter) +#ifdef QT3_SUPPORT + typedef Filters FilterSpec; +#endif + + enum SortFlag { Name = 0x00, + Time = 0x01, + Size = 0x02, + Unsorted = 0x03, + SortByMask = 0x03, + + DirsFirst = 0x04, + Reversed = 0x08, + IgnoreCase = 0x10, + DirsLast = 0x20, + LocaleAware = 0x40, + Type = 0x80, + NoSort = -1 +#ifdef QT3_SUPPORT + ,DefaultSort = NoSort +#endif + }; + Q_DECLARE_FLAGS(SortFlags, SortFlag) + + QDir(const QDir &); + QDir(const QString &path = QString()); + QDir(const QString &path, const QString &nameFilter, + SortFlags sort = SortFlags(Name | IgnoreCase), Filters filter = AllEntries); + ~QDir(); + + QDir &operator=(const QDir &); + QDir &operator=(const QString &path); + + void setPath(const QString &path); + QString path() const; + QString absolutePath() const; + QString canonicalPath() const; + + static void addResourceSearchPath(const QString &path); + + static void setSearchPaths(const QString &prefix, const QStringList &searchPaths); + static void addSearchPath(const QString &prefix, const QString &path); + static QStringList searchPaths(const QString &prefix); + + QString dirName() const; + QString filePath(const QString &fileName) const; + QString absoluteFilePath(const QString &fileName) const; + QString relativeFilePath(const QString &fileName) const; + +#ifdef QT_DEPRECATED + QT_DEPRECATED static QString convertSeparators(const QString &pathName); +#endif + static QString toNativeSeparators(const QString &pathName); + static QString fromNativeSeparators(const QString &pathName); + + bool cd(const QString &dirName); + bool cdUp(); + + QStringList nameFilters() const; + void setNameFilters(const QStringList &nameFilters); + + Filters filter() const; + void setFilter(Filters filter); + SortFlags sorting() const; + void setSorting(SortFlags sort); + + uint count() const; + QString operator[](int) const; + + static QStringList nameFiltersFromString(const QString &nameFilter); + + QStringList entryList(Filters filters = NoFilter, SortFlags sort = NoSort) const; + QStringList entryList(const QStringList &nameFilters, Filters filters = NoFilter, + SortFlags sort = NoSort) const; + + QFileInfoList entryInfoList(Filters filters = NoFilter, SortFlags sort = NoSort) const; + QFileInfoList entryInfoList(const QStringList &nameFilters, Filters filters = NoFilter, + SortFlags sort = NoSort) const; + + bool mkdir(const QString &dirName) const; + bool rmdir(const QString &dirName) const; + bool mkpath(const QString &dirPath) const; + bool rmpath(const QString &dirPath) const; + + bool isReadable() const; + bool exists() const; + bool isRoot() const; + + static bool isRelativePath(const QString &path); + inline static bool isAbsolutePath(const QString &path) { return !isRelativePath(path); } + bool isRelative() const; + inline bool isAbsolute() const { return !isRelative(); } + bool makeAbsolute(); + + bool operator==(const QDir &dir) const; + inline bool operator!=(const QDir &dir) const { return !operator==(dir); } + + bool remove(const QString &fileName); + bool rename(const QString &oldName, const QString &newName); + bool exists(const QString &name) const; + virtual bool exists( const QString &name, bool acceptAbsPath = TRUE ); + + static QFileInfoList drives(); + + static QChar separator(); + + static bool setCurrent(const QString &path); + static inline QDir current() { return QDir(currentPath()); } + static QString currentPath(); + + static inline QDir home() { return QDir(homePath()); } + static QString homePath(); + static inline QDir root() { return QDir(rootPath()); } + static QString rootPath(); + static inline QDir temp() { return QDir(tempPath()); } + static QString tempPath(); + +#ifndef QT_NO_REGEXP + static bool match(const QStringList &filters, const QString &fileName); + static bool match(const QString &filter, const QString &fileName); +#endif + static QString cleanPath(const QString &path); + void refresh() const; + +#ifdef QT3_SUPPORT + typedef SortFlags SortSpec; + inline QT3_SUPPORT QString absPath() const { return absolutePath(); } + inline QT3_SUPPORT QString absFilePath(const QString &fileName, bool acceptAbsPath = true) const + { Q_UNUSED(acceptAbsPath); return absoluteFilePath(fileName); } + QT3_SUPPORT bool matchAllDirs() const; + QT3_SUPPORT void setMatchAllDirs(bool on); + inline QT3_SUPPORT QStringList entryList(const QString &nameFilter, Filters filters = NoFilter, + SortFlags sort = NoSort) const + { return entryList(nameFiltersFromString(nameFilter), filters, sort); } + inline QT3_SUPPORT QFileInfoList entryInfoList(const QString &nameFilter, + Filters filters = NoFilter, + SortFlags sort = NoSort) const + { return entryInfoList(nameFiltersFromString(nameFilter), filters, sort); } + + QT3_SUPPORT QString nameFilter() const; + QT3_SUPPORT void setNameFilter(const QString &nameFilter); + + inline QT3_SUPPORT bool mkdir(const QString &dirName, bool acceptAbsPath) const + { Q_UNUSED(acceptAbsPath); return mkdir(dirName); } + inline QT3_SUPPORT bool rmdir(const QString &dirName, bool acceptAbsPath) const + { Q_UNUSED(acceptAbsPath); return rmdir(dirName); } + + inline QT3_SUPPORT void convertToAbs() { makeAbsolute(); } + inline QT3_SUPPORT static QString currentDirPath() { return currentPath(); } + inline QT3_SUPPORT static QString homeDirPath() { return homePath(); } + inline QT3_SUPPORT static QString rootDirPath() { return rootPath(); } + inline QT3_SUPPORT static QString cleanDirPath(const QString &name) { return cleanPath(name); } +#endif +}; + +Q_DECLARE_OPERATORS_FOR_FLAGS(QDir::Filters) +Q_DECLARE_OPERATORS_FOR_FLAGS(QDir::SortFlags) + +#ifndef QT_NO_DEBUG_STREAM +class QDebug; +Q_CORE_EXPORT QDebug operator<<(QDebug debug, QDir::Filters filters); +Q_CORE_EXPORT QDebug operator<<(QDebug debug, const QDir &dir); +#endif + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QDIR_H diff --git a/qtinterface/tqt4/Qt/qlist.h b/qtinterface/tqt4/Qt/qlist.h index 39c3b83..fb4d3e3 100644 --- a/qtinterface/tqt4/Qt/qlist.h +++ b/qtinterface/tqt4/Qt/qlist.h @@ -110,8 +110,8 @@ class QList union { QListData p; QListData::Data *d; }; public: - inline QList() : d(&QListData::shared_null) { d->ref.ref(); } - inline QList(const QList &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach_helper(); } + inline QList() : d(&QListData::shared_null) { d->ref.ref(); current_index=0; } + inline QList(const QList &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach_helper(); current_index=0; } ~QList(); QList &operator=(const QList &l); bool operator==(const QList &l) const; @@ -120,6 +120,7 @@ public: operator bool() const; inline operator const QList *() const { return const_cast *>(this); } + inline operator QList *() const { return const_cast *>(this); } inline int size() const { return p.size(); } @@ -159,8 +160,12 @@ public: int indexOf(const T &t, int from = 0) const; int lastIndexOf(const T &t, int from = -1) const; QBool contains(const T &t) const; + inline uint containsRef( const T &t ) { return count(t); }; int count(const T &t) const; + inline T next() { current_index++; return *this[current_index]; } + inline T prev() { current_index--; return *this[current_index]; } + class const_iterator; class iterator { @@ -264,10 +269,10 @@ public: typedef const_iterator ConstIterator; inline int count() const { return p.size(); } inline int length() const { return p.size(); } // Same as count() - inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); } - inline const T& first() const { Q_ASSERT(!isEmpty()); return *begin(); } + inline T& first() { Q_ASSERT(!isEmpty()); current_index=0; return *begin(); } + inline const T& first() const { Q_ASSERT(!isEmpty()); current_index=0; return *begin(); } T& last() { Q_ASSERT(!isEmpty()); return *(--end()); } - const T& last() const { Q_ASSERT(!isEmpty()); return *(--end()); } + const T& last() const { Q_ASSERT(!isEmpty()); current_index=count()-1; return *(--end()); } inline void removeFirst() { Q_ASSERT(!isEmpty()); erase(begin()); } inline void removeLast() { Q_ASSERT(!isEmpty()); erase(--end()); } inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; } @@ -341,6 +346,8 @@ private: void node_destruct(Node *n); void node_copy(Node *from, Node *to, Node *src); void node_destruct(Node *from, Node *to); + + int current_index; }; #if defined(Q_CC_BOR) diff --git a/qtinterface/tqt4/Qt/qmenu.h b/qtinterface/tqt4/Qt/qmenu.h new file mode 100644 index 0000000..a64cd6c --- /dev/null +++ b/qtinterface/tqt4/Qt/qmenu.h @@ -0,0 +1,429 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial Usage +** Licensees holding valid Qt Commercial licenses may use this file in +** accordance with the Qt Commercial License Agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Nokia. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QMENU_H +#define QMENU_H + +#include +#include +#include +#include + +#ifdef QT3_SUPPORT +#include +#endif + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Gui) + +#ifndef QT_NO_MENU + +class QMenuPrivate; +class QStyleOptionMenuItem; +#ifdef QT3_SUPPORT +class QMenuItem; +#endif + +class Q_GUI_EXPORT QMenu : public QWidget +{ +private: + Q_OBJECT + Q_DECLARE_PRIVATE(QMenu) + + Q_PROPERTY(bool tearOffEnabled READ isTearOffEnabled WRITE setTearOffEnabled) + Q_PROPERTY(QString title READ title WRITE setTitle) + Q_PROPERTY(QIcon icon READ icon WRITE setIcon) + Q_PROPERTY(bool separatorsCollapsible READ separatorsCollapsible WRITE setSeparatorsCollapsible) + +public: + explicit QMenu(QWidget *parent = 0); + explicit QMenu(const QString &title, QWidget *parent = 0); + ~QMenu(); + +#ifdef Q_NO_USING_KEYWORD + inline void addAction(QAction *action) { QWidget::addAction(action); } +#else + using QWidget::addAction; +#endif + QAction *addAction(const QString &text); + QAction *addAction(const QIcon &icon, const QString &text); + QAction *addAction(const QString &text, const QObject *receiver, const char* member, const QKeySequence &shortcut = 0); + QAction *addAction(const QIcon &icon, const QString &text, const QObject *receiver, const char* member, const QKeySequence &shortcut = 0); + + QAction *addMenu(QMenu *menu); + QMenu *addMenu(const QString &title); + QMenu *addMenu(const QIcon &icon, const QString &title); + + QAction *addSeparator(); + + QAction *insertMenu(QAction *before, QMenu *menu); + QAction *insertSeparator(QAction *before); + + bool isEmpty() const; + void clear(); + + void setTearOffEnabled(bool); + bool isTearOffEnabled() const; + + bool isTearOffMenuVisible() const; + void hideTearOffMenu(); + + void setDefaultAction(QAction *); + QAction *defaultAction() const; + + void setActiveAction(QAction *act); + QAction *activeAction() const; + + void popup(const QPoint &pos, QAction *at=0); + QAction *exec(); + QAction *exec(const QPoint &pos, QAction *at=0); + + // ### Qt 5: merge + static QAction *exec(QList actions, const QPoint &pos, QAction *at=0); + static QAction *exec(QList actions, const QPoint &pos, QAction *at, QWidget *parent); + + QSize sizeHint() const; + + QRect actionGeometry(QAction *) const; + QAction *actionAt(const QPoint &) const; + + QAction *menuAction() const; + + QString title() const; + void setTitle(const QString &title); + + QIcon icon() const; + void setIcon(const QIcon &icon); + + void setNoReplayFor(QWidget *widget); +#ifdef Q_WS_MAC + OSMenuRef macMenu(OSMenuRef merge=0); +#endif + +#ifdef Q_WS_WINCE + HMENU wceMenu(bool create = false); +#endif + + bool separatorsCollapsible() const; + void setSeparatorsCollapsible(bool collapse); + +Q_SIGNALS: + void aboutToShow(); + void aboutToHide(); + void triggered(QAction *action); + void hovered(QAction *action); + +protected: + int columnCount() const; + + void changeEvent(QEvent *); + void keyPressEvent(QKeyEvent *); + void mouseReleaseEvent(QMouseEvent *); + void mousePressEvent(QMouseEvent *); + void mouseMoveEvent(QMouseEvent *); + void wheelEvent(QWheelEvent *); + void enterEvent(QEvent *); + void leaveEvent(QEvent *); + void hideEvent(QHideEvent *); + void paintEvent(QPaintEvent *); + void actionEvent(QActionEvent *); + void timerEvent(QTimerEvent *); + bool event(QEvent *); + bool focusNextPrevChild(bool next); + void initStyleOption(QStyleOptionMenuItem *option, const QAction *action) const; + +#ifdef Q_WS_WINCE + QAction* wceCommands(uint command); +#endif + +private Q_SLOTS: + void internalSetSloppyAction(); + void internalDelayedPopup(); + +private: + Q_PRIVATE_SLOT(d_func(), void _q_actionTriggered()) + Q_PRIVATE_SLOT(d_func(), void _q_actionHovered()) + Q_PRIVATE_SLOT(d_func(), void _q_overrideMenuActionDestroyed()) + +#ifdef QT3_SUPPORT +public: + //menudata + inline QT3_SUPPORT uint count() const { return actions().count(); } + inline QT3_SUPPORT int insertItem(const QString &text, const QObject *receiver, const char* member, + const QKeySequence& shortcut = 0, int id = -1, int index = -1) { + return insertAny(0, &text, receiver, member, &shortcut, 0, id, index); + } + inline QT3_SUPPORT int insertItem(const QIcon& icon, const QString &text, + const QObject *receiver, const char* member, + const QKeySequence& shortcut = 0, int id = -1, int index = -1) { + return insertAny(&icon, &text, receiver, member, &shortcut, 0, id, index); + } + inline QT3_SUPPORT int insertItem(const QPixmap &pixmap, const QObject *receiver, const char* member, + const QKeySequence& shortcut = 0, int id = -1, int index = -1) { + QIcon icon(pixmap); + return insertAny(&icon, 0, receiver, member, &shortcut, 0, id, index); + } + inline QT3_SUPPORT int insertItem(const QString &text, int id=-1, int index=-1) { + return insertAny(0, &text, 0, 0, 0, 0, id, index); + } + inline QT3_SUPPORT int insertItem(const QIcon& icon, const QString &text, int id=-1, int index=-1) { + return insertAny(&icon, &text, 0, 0, 0, 0, id, index); + } + inline QT3_SUPPORT int insertItem(const QString &text, QMenu *popup, int id=-1, int index=-1) { + return insertAny(0, &text, 0, 0, 0, popup, id, index); + } + inline QT3_SUPPORT int insertItem(const QIcon& icon, const QString &text, QMenu *popup, int id=-1, int index=-1) { + return insertAny(&icon, &text, 0, 0, 0, popup, id, index); + } + inline QT3_SUPPORT int insertItem(const QPixmap &pixmap, int id=-1, int index=-1) { + QIcon icon(pixmap); + return insertAny(&icon, 0, 0, 0, 0, 0, id, index); + } + inline QT3_SUPPORT int insertItem(const QPixmap &pixmap, QMenu *popup, int id=-1, int index=-1) { + QIcon icon(pixmap); + return insertAny(&icon, 0, 0, 0, 0, popup, id, index); + } + QT3_SUPPORT int insertItem(QMenuItem *item, int id=-1, int index=-1); + int insertItem( QWidget* widget, int id=-1, int index=-1 ); + + QT3_SUPPORT int insertSeparator(int index=-1); + inline QT3_SUPPORT void removeItem(int id) { + if(QAction *act = findActionForId(id)) + removeAction(act); } + inline QT3_SUPPORT void removeItemAt(int index) { + if(QAction *act = actions().value(index)) + removeAction(act); } +#ifndef QT_NO_SHORTCUT + inline QT3_SUPPORT QKeySequence accel(int id) const { + if(QAction *act = findActionForId(id)) + return act->shortcut(); + return QKeySequence(); } + inline QT3_SUPPORT void setAccel(const QKeySequence& key, int id) { + if(QAction *act = findActionForId(id)) + act->setShortcut(key); + } +#endif + inline QT3_SUPPORT QIcon iconSet(int id) const { + if(QAction *act = findActionForId(id)) + return act->icon(); + return QIcon(); } + inline QT3_SUPPORT QString text(int id) const { + if(QAction *act = findActionForId(id)) + return act->text(); + return QString(); } + inline QT3_SUPPORT QPixmap pixmap(int id) const { + if(QAction *act = findActionForId(id)) + return act->icon().pixmap(QSize(22, 22)); + return QPixmap(); } + inline QT3_SUPPORT void setWhatsThis(int id, const QString &w) { + if(QAction *act = findActionForId(id)) + act->setWhatsThis(w); } + inline QT3_SUPPORT QString whatsThis(int id) const { + if(QAction *act = findActionForId(id)) + return act->whatsThis(); + return QString(); } + + inline QT3_SUPPORT void changeItem(int id, const QString &text) { + if(QAction *act = findActionForId(id)) + act->setText(text); } + inline QT3_SUPPORT void changeItem(int id, const QPixmap &pixmap) { + if(QAction *act = findActionForId(id)) + act->setIcon(QIcon(pixmap)); } + inline QT3_SUPPORT void changeItem(int id, const QIcon &icon, const QString &text) { + if(QAction *act = findActionForId(id)) { + act->setIcon(icon); + act->setText(text); + } + } + inline QT3_SUPPORT void setActiveItem(int id) { + setActiveAction(findActionForId(id)); + } + inline QT3_SUPPORT bool isItemActive(int id) const { + return findActionForId(id) == activeAction(); + } + inline QT3_SUPPORT bool isItemEnabled(int id) const { + if(QAction *act = findActionForId(id)) + return act->isEnabled(); + return false; } + inline QT3_SUPPORT void setItemEnabled(int id, bool enable) { + if(QAction *act = findActionForId(id)) + act->setEnabled(enable); + } + inline QT3_SUPPORT bool isItemChecked(int id) const { + if(QAction *act = findActionForId(id)) + return act->isChecked(); + return false; + } + inline QT3_SUPPORT void setItemChecked(int id, bool check) { + if(QAction *act = findActionForId(id)) { + act->setCheckable(true); + act->setChecked(check); + } + } + inline QT3_SUPPORT bool isItemVisible(int id) const { + if(QAction *act = findActionForId(id)) + return act->isVisible(); + return false; + } + inline QT3_SUPPORT void setItemVisible(int id, bool visible) { + if(QAction *act = findActionForId(id)) + act->setVisible(visible); + } + inline QT3_SUPPORT QRect itemGeometry(int index) { + if(QAction *act = actions().value(index)) + return actionGeometry(act); + return QRect(); + } + inline QT3_SUPPORT QFont itemFont(int id) const { + if(QAction *act = findActionForId(id)) + return act->font(); + return QFont(); + } + inline QT3_SUPPORT void setItemFont(int id, const QFont &font) { + if(QAction *act = findActionForId(id)) + act->setFont(font); + } + inline QT3_SUPPORT int indexOf(int id) const { + return actions().indexOf(findActionForId(id)); + } + inline QT3_SUPPORT int idAt(int index) const { + return findIdForAction(actions().value(index)); + } + QT3_SUPPORT void setId (int index, int id); + inline QT3_SUPPORT void activateItemAt(int index) { + if(QAction *ret = actions().value(index)) + ret->activate(QAction::Trigger); + } + inline QT3_SUPPORT bool connectItem(int id, const QObject *receiver, const char* member) { + if(QAction *act = findActionForId(id)) { + QObject::connect(act, SIGNAL(activated(int)), receiver, member); + return true; + } + return false; + } + inline QT3_SUPPORT bool disconnectItem(int id,const QObject *receiver, const char* member) { + if(QAction *act = findActionForId(id)) { + QObject::disconnect(act, SIGNAL(triggered()), receiver, member); + return true; + } + return false; + } + inline QT3_SUPPORT QMenuItem *findItem(int id) const { + return reinterpret_cast(findActionForId(id)); + } + + inline QT3_SUPPORT void setCheckable(bool){} + inline QT3_SUPPORT bool isCheckable() const {return true;} + + QT3_SUPPORT QMenuItem *findPopup( QMenu *popup, int *index ); + + QT3_SUPPORT bool setItemParameter(int id, int param); + QT3_SUPPORT int itemParameter(int id) const; + + //frame + QT3_SUPPORT int frameWidth() const; + + //popupmenu + inline QT3_SUPPORT void popup(const QPoint & pos, int indexAtPoint) { popup(pos, actions().value(indexAtPoint)); } + inline QT3_SUPPORT int insertTearOffHandle(int = 0, int = 0) { + setTearOffEnabled(true); + return -1; + } + +protected: + inline QT3_SUPPORT int itemAtPos(const QPoint &p, bool ignoreSeparator = true) { + QAction *ret = actionAt(p); + if(ignoreSeparator && ret && ret->isSeparator()) + return -1; + return findIdForAction(ret); + } + inline QT3_SUPPORT int columns() const { return columnCount(); } + inline QT3_SUPPORT int itemHeight(int index) { + return actionGeometry(actions().value(index)).height(); + } + inline QT3_SUPPORT int itemHeight(QMenuItem *mi) { + return actionGeometry(reinterpret_cast(mi)).height(); + } + +Q_SIGNALS: + QT_MOC_COMPAT void activated(int itemId); + QT_MOC_COMPAT void highlighted(int itemId); + +private: + int insertAny(const QIcon *icon, const QString *text, const QObject *receiver, const char *member, + const QKeySequence *shorcut, const QMenu *popup, int id, int index); + QAction *findActionForId(int id) const; + int findIdForAction(QAction*) const; +#endif + +protected: + QMenu(QMenuPrivate &dd, QWidget* parent = 0); + +private: + Q_DISABLE_COPY(QMenu) + + friend class QMenuBar; + friend class QMenuBarPrivate; + friend class QTornOffMenu; + friend class Q3PopupMenu; + friend class QComboBox; + friend class QAction; + friend class QToolButtonPrivate; + +#ifdef Q_WS_MAC + friend void qt_mac_trayicon_activate_action(QMenu *, QAction *action); + friend bool qt_mac_watchingAboutToShow(QMenu *); + friend OSStatus qt_mac_menu_event(EventHandlerCallRef, EventRef, void *); + friend bool qt_mac_activate_action(OSMenuRef, uint, QAction::ActionEvent, bool); + friend void qt_mac_emit_menuSignals(QMenu *, bool); +#endif +}; + +#endif // QT_NO_MENU + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QMENU_H diff --git a/qtinterface/tqt4/Qt/qpixmap.h b/qtinterface/tqt4/Qt/qpixmap.h index db2eda4..79c69a3 100644 --- a/qtinterface/tqt4/Qt/qpixmap.h +++ b/qtinterface/tqt4/Qt/qpixmap.h @@ -244,6 +244,7 @@ public: void setOptimization( Optimization ); static Optimization defaultOptimization(); static void setDefaultOptimization( Optimization ); + operator QPixmap *() const; #endif private: diff --git a/qtinterface/tqt4/Qt/qtooltip.h b/qtinterface/tqt4/Qt/qtooltip.h new file mode 100644 index 0000000..260d8c3 --- /dev/null +++ b/qtinterface/tqt4/Qt/qtooltip.h @@ -0,0 +1,87 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtGui module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial Usage +** Licensees holding valid Qt Commercial licenses may use this file in +** accordance with the Qt Commercial License Agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Nokia. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QTOOLTIP_H +#define QTOOLTIP_H + +#include + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Gui) + +#ifndef QT_NO_TOOLTIP + +class Q_GUI_EXPORT QToolTip +{ + QToolTip(); +public: + static void showText(const QPoint &pos, const QString &text, QWidget *w = 0); + static void showText(const QPoint &pos, const QString &text, QWidget *w, const QRect &rect); + static inline void hideText() { showText(QPoint(), QString()); } + + static bool isVisible(); + static QString text(); + + static QPalette palette(); + static void setPalette(const QPalette &); + static QFont font(); + static void setFont(const QFont &); +#ifdef QT3_SUPPORT + static inline QT3_SUPPORT void add(QWidget *w, const QString &s) { w->setToolTip(s); } + static inline QT3_SUPPORT void add(QWidget *w, const QRect &, const QString &s) + { w->setToolTip(s); } + static inline QT3_SUPPORT void remove(QWidget *w) { w->setToolTip(QString()); } +#endif + + static void setGloballyEnabled( bool ); + static bool isGloballyEnabled(); +}; + +#endif // QT_NO_TOOLTIP + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QTOOLTIP_H diff --git a/qtinterface/tqt4/Qt/qvector.h b/qtinterface/tqt4/Qt/qvector.h new file mode 100644 index 0000000..301f163 --- /dev/null +++ b/qtinterface/tqt4/Qt/qvector.h @@ -0,0 +1,802 @@ +/**************************************************************************** +** +** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the QtCore module of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial Usage +** Licensees holding valid Qt Commercial licenses may use this file in +** accordance with the Qt Commercial License Agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Nokia. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QVECTOR_H +#define QVECTOR_H + +#include +#include +#include +#include + +#ifndef QT_NO_STL +#include +#include +#endif +#include +#include + +QT_BEGIN_HEADER + +QT_BEGIN_NAMESPACE + +QT_MODULE(Core) + +struct Q_CORE_EXPORT QVectorData +{ + QBasicAtomicInt ref; + int alloc; + int size; +#if defined(QT_ARCH_SPARC) && defined(Q_CC_GNU) && defined(__LP64__) && defined(QT_BOOTSTRAPPED) + // workaround for bug in gcc 3.4.2 + uint sharable; + uint capacity; + uint reserved; +#else + uint sharable : 1; + uint capacity : 1; + uint reserved : 30; +#endif + + static QVectorData shared_null; + // ### Qt 5: rename to 'allocate()'. The current name causes problems for + // some debugges when the QVector is member of a class within an unnamed namespace. + // ### Qt 5: can be removed completely. (Ralf) + static QVectorData *malloc(int sizeofTypedData, int size, int sizeofT, QVectorData *init); + static QVectorData *allocate(int size, int alignment); + static QVectorData *reallocate(QVectorData *old, int newsize, int oldsize, int alignment); + static void free(QVectorData *data, int alignment); + static int grow(int sizeofTypedData, int size, int sizeofT, bool excessive); +}; + +template +struct QVectorTypedData : private QVectorData +{ // private inheritance as we must not access QVectorData member thought QVectorTypedData + // as this would break strict aliasing rules. (in the case of shared_null) + T array[1]; + + static inline void free(QVectorTypedData *x, int alignment) { QVectorData::free(static_cast(x), alignment); } +}; + +class QRegion; + +template +class QVector +{ + typedef QVectorTypedData Data; + union { + QVectorData *d; +#if defined(Q_CC_SUN) && (__SUNPRO_CC <= 0x550) + QVectorTypedData *p; +#else + Data *p; +#endif + }; + +public: + inline QVector() : d(&QVectorData::shared_null) { d->ref.ref(); } + explicit QVector(int size); + QVector(int size, const T &t); + inline QVector(const QVector &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); } + inline ~QVector() { if (!d) return; if (!d->ref.deref()) free(p); } + QVector &operator=(const QVector &v); + bool operator==(const QVector &v) const; + inline bool operator!=(const QVector &v) const { return !(*this == v); } + + inline int size() const { return d->size; } + + inline bool isEmpty() const { return d->size == 0; } + + void resize(int size); + + inline int capacity() const { return d->alloc; } + void reserve(int size); + inline void squeeze() { realloc(d->size, d->size); d->capacity = 0; } + + inline void detach() { if (d->ref != 1) detach_helper(); } + inline bool isDetached() const { return d->ref == 1; } + inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } + + inline T *data() { detach(); return p->array; } + inline const T *data() const { return p->array; } + inline const T *constData() const { return p->array; } + void clear(); + + inline operator unsigned int *() const { return p->array; } + + const T &at(int i) const; + T &operator[](int i); + const T &operator[](int i) const; + void append(const T &t); + void prepend(const T &t); + void insert(int i, const T &t); + void insert(int i, int n, const T &t); + void replace(int i, const T &t); + void remove(int i); + void remove(int i, int n); + + QVector &fill(const T &t, int size = -1); + + int indexOf(const T &t, int from = 0) const; + int lastIndexOf(const T &t, int from = -1) const; + bool contains(const T &t) const; + int count(const T &t) const; + +#ifdef QT_STRICT_ITERATORS + class iterator { + public: + T *i; + typedef std::random_access_iterator_tag iterator_category; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef T *pointer; + typedef T &reference; + + inline iterator() : i(0) {} + inline iterator(T *n) : i(n) {} + inline iterator(const iterator &o): i(o.i){} + inline T &operator*() const { return *i; } + inline T *operator->() const { return i; } + inline T &operator[](int j) const { return *(i + j); } + inline bool operator==(const iterator &o) const { return i == o.i; } + inline bool operator!=(const iterator &o) const { return i != o.i; } + inline bool operator<(const iterator& other) const { return i < other.i; } + inline bool operator<=(const iterator& other) const { return i <= other.i; } + inline bool operator>(const iterator& other) const { return i > other.i; } + inline bool operator>=(const iterator& other) const { return i >= other.i; } + inline iterator &operator++() { ++i; return *this; } + inline iterator operator++(int) { T *n = i; ++i; return n; } + inline iterator &operator--() { i--; return *this; } + inline iterator operator--(int) { T *n = i; i--; return n; } + inline iterator &operator+=(int j) { i+=j; return *this; } + inline iterator &operator-=(int j) { i-=j; return *this; } + inline iterator operator+(int j) const { return iterator(i+j); } + inline iterator operator-(int j) const { return iterator(i-j); } + inline int operator-(iterator j) const { return i - j.i; } + }; + friend class iterator; + + class const_iterator { + public: + T *i; + typedef std::random_access_iterator_tag iterator_category; + typedef ptrdiff_t difference_type; + typedef T value_type; + typedef const T *pointer; + typedef const T &reference; + + inline const_iterator() : i(0) {} + inline const_iterator(T *n) : i(n) {} + inline const_iterator(const const_iterator &o): i(o.i) {} + inline explicit const_iterator(const iterator &o): i(o.i) {} + inline const T &operator*() const { return *i; } + inline const T *operator->() const { return i; } + inline const T &operator[](int j) const { return *(i + j); } + inline bool operator==(const const_iterator &o) const { return i == o.i; } + inline bool operator!=(const const_iterator &o) const { return i != o.i; } + inline bool operator<(const const_iterator& other) const { return i < other.i; } + inline bool operator<=(const const_iterator& other) const { return i <= other.i; } + inline bool operator>(const const_iterator& other) const { return i > other.i; } + inline bool operator>=(const const_iterator& other) const { return i >= other.i; } + inline const_iterator &operator++() { ++i; return *this; } + inline const_iterator operator++(int) { T *n = i; ++i; return n; } + inline const_iterator &operator--() { i--; return *this; } + inline const_iterator operator--(int) { T *n = i; i--; return n; } + inline const_iterator &operator+=(int j) { i+=j; return *this; } + inline const_iterator &operator-=(int j) { i-=j; return *this; } + inline const_iterator operator+(int j) const { return const_iterator(i+j); } + inline const_iterator operator-(int j) const { return const_iterator(i-j); } + inline int operator-(const_iterator j) const { return i - j.i; } + }; + friend class const_iterator; +#else + // STL-style + typedef T* iterator; + typedef const T* const_iterator; +#endif + inline iterator begin() { detach(); return p->array; } + inline const_iterator begin() const { return p->array; } + inline const_iterator constBegin() const { return p->array; } + inline iterator end() { detach(); return p->array + d->size; } + inline const_iterator end() const { return p->array + d->size; } + inline const_iterator constEnd() const { return p->array + d->size; } + iterator insert(iterator before, int n, const T &x); + inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); } + iterator erase(iterator begin, iterator end); + inline iterator erase(iterator pos) { return erase(pos, pos+1); } + + // more Qt + inline int count() const { return d->size; } + inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); } + inline const T &first() const { Q_ASSERT(!isEmpty()); return *begin(); } + inline T& last() { Q_ASSERT(!isEmpty()); return *(end()-1); } + inline const T &last() const { Q_ASSERT(!isEmpty()); return *(end()-1); } + inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; } + inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; } + QVector mid(int pos, int length = -1) const; + + T value(int i) const; + T value(int i, const T &defaultValue) const; + + // STL compatibility + typedef T value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef ptrdiff_t difference_type; + typedef iterator Iterator; + typedef const_iterator ConstIterator; + typedef int size_type; + inline void push_back(const T &t) { append(t); } + inline void push_front(const T &t) { prepend(t); } + void pop_back() { Q_ASSERT(!isEmpty()); erase(end()-1); } + void pop_front() { Q_ASSERT(!isEmpty()); erase(begin()); } + inline bool empty() const + { return d->size == 0; } + inline T& front() { return first(); } + inline const_reference front() const { return first(); } + inline reference back() { return last(); } + inline const_reference back() const { return last(); } + + // comfort + QVector &operator+=(const QVector &l); + inline QVector operator+(const QVector &l) const + { QVector n = *this; n += l; return n; } + inline QVector &operator+=(const T &t) + { append(t); return *this; } + inline QVector &operator<< (const T &t) + { append(t); return *this; } + inline QVector &operator<<(const QVector &l) + { *this += l; return *this; } + + QList toList() const; + + static QVector fromList(const QList &list); + +#ifndef QT_NO_STL + static inline QVector fromStdVector(const std::vector &vector) + { QVector tmp; qCopy(vector.begin(), vector.end(), std::back_inserter(tmp)); return tmp; } + inline std::vector toStdVector() const + { std::vector tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; } +#endif + +private: + friend class QRegion; // Optimization for QRegion::rects() + + void detach_helper(); + QVectorData *malloc(int alloc); + void realloc(int size, int alloc); + void free(Data *d); + int sizeOfTypedData() { + // this is more or less the same as sizeof(Data), except that it doesn't + // count the padding at the end + return reinterpret_cast(&(reinterpret_cast(this))->array[1]) - reinterpret_cast(this); + } + inline int alignOfTypedData() const + { +#ifdef Q_ALIGNOF + return qMax(sizeof(void*), Q_ALIGNOF(Data)); +#else + return 0; +#endif + } +}; + +template +void QVector::detach_helper() +{ realloc(d->size, d->alloc); } +template +void QVector::reserve(int asize) +{ if (asize > d->alloc) realloc(d->size, asize); if (d->ref == 1) d->capacity = 1; } +template +void QVector::resize(int asize) +{ realloc(asize, (asize > d->alloc || (!d->capacity && asize < d->size && asize < (d->alloc >> 1))) ? + QVectorData::grow(sizeOfTypedData(), asize, sizeof(T), QTypeInfo::isStatic) + : d->alloc); } +template +inline void QVector::clear() +{ *this = QVector(); } +template +inline const T &QVector::at(int i) const +{ Q_ASSERT_X(i >= 0 && i < d->size, "QVector::at", "index out of range"); + return p->array[i]; } +template +inline const T &QVector::operator[](int i) const +{ Q_ASSERT_X(i >= 0 && i < d->size, "QVector::operator[]", "index out of range"); + return p->array[i]; } +template +inline T &QVector::operator[](int i) +{ Q_ASSERT_X(i >= 0 && i < d->size, "QVector::operator[]", "index out of range"); + return data()[i]; } +template +inline void QVector::insert(int i, const T &t) +{ Q_ASSERT_X(i >= 0 && i <= d->size, "QVector::insert", "index out of range"); + insert(begin() + i, 1, t); } +template +inline void QVector::insert(int i, int n, const T &t) +{ Q_ASSERT_X(i >= 0 && i <= d->size, "QVector::insert", "index out of range"); + insert(begin() + i, n, t); } +template +inline void QVector::remove(int i, int n) +{ Q_ASSERT_X(i >= 0 && n >= 0 && i + n <= d->size, "QVector::remove", "index out of range"); + erase(begin() + i, begin() + i + n); } +template +inline void QVector::remove(int i) +{ Q_ASSERT_X(i >= 0 && i < d->size, "QVector::remove", "index out of range"); + erase(begin() + i, begin() + i + 1); } +template +inline void QVector::prepend(const T &t) +{ insert(begin(), 1, t); } + +template +inline void QVector::replace(int i, const T &t) +{ + Q_ASSERT_X(i >= 0 && i < d->size, "QVector::replace", "index out of range"); + const T copy(t); + data()[i] = copy; +} + +template +QVector &QVector::operator=(const QVector &v) +{ + v.d->ref.ref(); + if (!d->ref.deref()) + free(p); + d = v.d; + if (!d->sharable) + detach_helper(); + return *this; +} + +template +inline QVectorData *QVector::malloc(int aalloc) +{ + QVectorData *vectordata = QVectorData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData()); + Q_CHECK_PTR(vectordata); + return vectordata; +} + +template +QVector::QVector(int asize) +{ + d = malloc(asize); + d->ref = 1; + d->alloc = d->size = asize; + d->sharable = true; + d->capacity = false; + if (QTypeInfo::isComplex) { + T* b = p->array; + T* i = p->array + d->size; + while (i != b) + new (--i) T; + } else { + qMemSet(p->array, 0, asize * sizeof(T)); + } +} + +template +QVector::QVector(int asize, const T &t) +{ + d = malloc(asize); + d->ref = 1; + d->alloc = d->size = asize; + d->sharable = true; + d->capacity = false; + T* i = p->array + d->size; + while (i != p->array) + new (--i) T(t); +} + +template +void QVector::free(Data *x) +{ + if (QTypeInfo::isComplex) { + T* b = x->array; + union { QVectorData *d; Data *p; } u; + u.p = x; + T* i = b + u.d->size; + while (i-- != b) + i->~T(); + } + x->free(x, alignOfTypedData()); +} + +template +void QVector::realloc(int asize, int aalloc) +{ + Q_ASSERT(asize <= aalloc); + T *pOld; + T *pNew; + union { QVectorData *d; Data *p; } x; + x.d = d; + + if (QTypeInfo::isComplex && asize < d->size && d->ref == 1 ) { + // call the destructor on all objects that need to be + // destroyed when shrinking + pOld = p->array + d->size; + pNew = p->array + asize; + while (asize < d->size) { + (--pOld)->~T(); + d->size--; + } + } + + if (aalloc != d->alloc || d->ref != 1) { + // (re)allocate memory + if (QTypeInfo::isStatic) { + x.d = malloc(aalloc); + Q_CHECK_PTR(x.p); + x.d->size = 0; + } else if (d->ref != 1) { + x.d = malloc(aalloc); + Q_CHECK_PTR(x.p); + if (QTypeInfo::isComplex) { + x.d->size = 0; + } else { + ::memcpy(x.p, p, sizeOfTypedData() + (qMin(aalloc, d->alloc) - 1) * sizeof(T)); + x.d->size = d->size; + } + } else { + QT_TRY { + QVectorData *mem = QVectorData::reallocate(d, sizeOfTypedData() + (aalloc - 1) * sizeof(T), + sizeOfTypedData() + (d->alloc - 1) * sizeof(T), alignOfTypedData()); + Q_CHECK_PTR(mem); + x.d = d = mem; + x.d->size = d->size; + } QT_CATCH (const std::bad_alloc &) { + if (aalloc > d->alloc) // ignore the error in case we are just shrinking. + QT_RETHROW; + } + } + x.d->ref = 1; + x.d->alloc = aalloc; + x.d->sharable = true; + x.d->capacity = d->capacity; + x.d->reserved = 0; + } + + if (QTypeInfo::isComplex) { + QT_TRY { + pOld = p->array + x.d->size; + pNew = x.p->array + x.d->size; + // copy objects from the old array into the new array + const int toMove = qMin(asize, d->size); + while (x.d->size < toMove) { + new (pNew++) T(*pOld++); + x.d->size++; + } + // construct all new objects when growing + while (x.d->size < asize) { + new (pNew++) T; + x.d->size++; + } + } QT_CATCH (...) { + free(x.p); + QT_RETHROW; + } + + } else if (asize > x.d->size) { + // initialize newly allocated memory to 0 + qMemSet(x.p->array + x.d->size, 0, (asize - x.d->size) * sizeof(T)); + } + x.d->size = asize; + + if (d != x.d) { + if (!d->ref.deref()) + free(p); + d = x.d; + } +} + +template +Q_OUTOFLINE_TEMPLATE T QVector::value(int i) const +{ + if (i < 0 || i >= d->size) { + return T(); + } + return p->array[i]; +} +template +Q_OUTOFLINE_TEMPLATE T QVector::value(int i, const T &defaultValue) const +{ + return ((i < 0 || i >= d->size) ? defaultValue : p->array[i]); +} + +template +void QVector::append(const T &t) +{ + if (d->ref != 1 || d->size + 1 > d->alloc) { + const T copy(t); + realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + 1, sizeof(T), + QTypeInfo::isStatic)); + if (QTypeInfo::isComplex) + new (p->array + d->size) T(copy); + else + p->array[d->size] = copy; + } else { + if (QTypeInfo::isComplex) + new (p->array + d->size) T(t); + else + p->array[d->size] = t; + } + ++d->size; +} + +template +Q_TYPENAME QVector::iterator QVector::insert(iterator before, size_type n, const T &t) +{ + int offset = int(before - p->array); + if (n != 0) { + const T copy(t); + if (d->ref != 1 || d->size + n > d->alloc) + realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + n, sizeof(T), + QTypeInfo::isStatic)); + if (QTypeInfo::isStatic) { + T *b = p->array + d->size; + T *i = p->array + d->size + n; + while (i != b) + new (--i) T; + i = p->array + d->size; + T *j = i + n; + b = p->array + offset; + while (i != b) + *--j = *--i; + i = b+n; + while (i != b) + *--i = copy; + } else { + T *b = p->array + offset; + T *i = b + n; + memmove(i, b, (d->size - offset) * sizeof(T)); + while (i != b) + new (--i) T(copy); + } + d->size += n; + } + return p->array + offset; +} + +template +Q_TYPENAME QVector::iterator QVector::erase(iterator abegin, iterator aend) +{ + int f = int(abegin - p->array); + int l = int(aend - p->array); + int n = l - f; + detach(); + if (QTypeInfo::isComplex) { + qCopy(p->array+l, p->array+d->size, p->array+f); + T *i = p->array+d->size; + T* b = p->array+d->size-n; + while (i != b) { + --i; + i->~T(); + } + } else { + memmove(p->array + f, p->array + l, (d->size-l)*sizeof(T)); + } + d->size -= n; + return p->array + f; +} + +template +bool QVector::operator==(const QVector &v) const +{ + if (d->size != v.d->size) + return false; + if (d == v.d) + return true; + T* b = p->array; + T* i = b + d->size; + T* j = v.p->array + d->size; + while (i != b) + if (!(*--i == *--j)) + return false; + return true; +} + +template +QVector &QVector::fill(const T &from, int asize) +{ + const T copy(from); + resize(asize < 0 ? d->size : asize); + if (d->size) { + T *i = p->array + d->size; + T *b = p->array; + while (i != b) + *--i = copy; + } + return *this; +} + +template +QVector &QVector::operator+=(const QVector &l) +{ + int newSize = d->size + l.d->size; + realloc(d->size, newSize); + + T *w = p->array + newSize; + T *i = l.p->array + l.d->size; + T *b = l.p->array; + while (i != b) { + if (QTypeInfo::isComplex) + new (--w) T(*--i); + else + *--w = *--i; + } + d->size = newSize; + return *this; +} + +template +int QVector::indexOf(const T &t, int from) const +{ + if (from < 0) + from = qMax(from + d->size, 0); + if (from < d->size) { + T* n = p->array + from - 1; + T* e = p->array + d->size; + while (++n != e) + if (*n == t) + return n - p->array; + } + return -1; +} + +template +int QVector::lastIndexOf(const T &t, int from) const +{ + if (from < 0) + from += d->size; + else if (from >= d->size) + from = d->size-1; + if (from >= 0) { + T* b = p->array; + T* n = p->array + from + 1; + while (n != b) { + if (*--n == t) + return n - b; + } + } + return -1; +} + +template +bool QVector::contains(const T &t) const +{ + T* b = p->array; + T* i = p->array + d->size; + while (i != b) + if (*--i == t) + return true; + return false; +} + +template +int QVector::count(const T &t) const +{ + int c = 0; + T* b = p->array; + T* i = p->array + d->size; + while (i != b) + if (*--i == t) + ++c; + return c; +} + +template +Q_OUTOFLINE_TEMPLATE QVector QVector::mid(int pos, int length) const +{ + if (length < 0) + length = size() - pos; + if (pos == 0 && length == size()) + return *this; + QVector copy; + if (pos + length > size()) + length = size() - pos; + for (int i = pos; i < pos + length; ++i) + copy += at(i); + return copy; +} + +template +Q_OUTOFLINE_TEMPLATE QList QVector::toList() const +{ + QList result; + for (int i = 0; i < size(); ++i) + result.append(at(i)); + return result; +} + +template +Q_OUTOFLINE_TEMPLATE QVector QList::toVector() const +{ + QVector result(size()); + for (int i = 0; i < size(); ++i) + result[i] = at(i); + return result; +} + +template +QVector QVector::fromList(const QList &list) +{ + return list.toVector(); +} + +template +QList QList::fromVector(const QVector &vector) +{ + return vector.toList(); +} + +Q_DECLARE_SEQUENTIAL_ITERATOR(Vector) +Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(Vector) + +/* + ### Qt 5: + ### This needs to be removed for next releases of Qt. It is a workaround for vc++ because + ### Qt exports QPolygon and QPolygonF that inherit QVector and + ### QVector respectively. +*/ + +#ifdef Q_CC_MSVC +QT_BEGIN_INCLUDE_NAMESPACE +#include +#include +QT_END_INCLUDE_NAMESPACE + +#if defined(QT_BUILD_CORE_LIB) +#define Q_TEMPLATE_EXTERN +#else +#define Q_TEMPLATE_EXTERN extern +#endif +# pragma warning(push) /* MSVC 6.0 doesn't care about the disabling in qglobal.h (why?), so do it here */ +# pragma warning(disable: 4231) /* nonstandard extension used : 'extern' before template explicit instantiation */ +Q_TEMPLATE_EXTERN template class Q_CORE_EXPORT QVector; +Q_TEMPLATE_EXTERN template class Q_CORE_EXPORT QVector; +# pragma warning(pop) +#endif + +QT_END_NAMESPACE + +QT_END_HEADER + +#endif // QVECTOR_H diff --git a/qtinterface/tqt4/Qt/qwidget.h b/qtinterface/tqt4/Qt/qwidget.h index c709689..355441f 100644 --- a/qtinterface/tqt4/Qt/qwidget.h +++ b/qtinterface/tqt4/Qt/qwidget.h @@ -251,6 +251,7 @@ public: bool isEnabledToTLW() const; Qt::WidgetAttribute testWState( Qt::WidgetAttribute s ) const; + Qt::WindowFlags testWFlags( Qt::WindowFlags f ) const; public Q_SLOTS: void setEnabled(bool); -- cgit v1.2.1