diff options
Diffstat (limited to 'src/designer/src/lib/shared/qdesigner_command_p.h')
-rw-r--r-- | src/designer/src/lib/shared/qdesigner_command_p.h | 1136 |
1 files changed, 1136 insertions, 0 deletions
diff --git a/src/designer/src/lib/shared/qdesigner_command_p.h b/src/designer/src/lib/shared/qdesigner_command_p.h new file mode 100644 index 000000000..323cec5e5 --- /dev/null +++ b/src/designer/src/lib/shared/qdesigner_command_p.h @@ -0,0 +1,1136 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the Qt Designer of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** 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. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +// +// W A R N I N G +// ------------- +// +// This file is not part of the Qt API. It exists for the convenience +// of Qt Designer. This header +// file may change from version to version without notice, or even be removed. +// +// We mean it. +// + +#ifndef QDESIGNER_COMMAND_H +#define QDESIGNER_COMMAND_H + +#include "shared_global_p.h" +#include "shared_enums_p.h" +#include "layoutinfo_p.h" +#include "qdesigner_utils_p.h" +#include "qdesigner_formwindowcommand_p.h" +#include "qdesigner_formeditorcommand_p.h" + +#include <QtDesigner/layoutdecoration.h> + +#include <QtGui/QIcon> +#include <QtCore/QObject> +#include <QtCore/QPair> +#include <QtCore/QMap> +#include <QtCore/QHash> +#include <QtCore/QPoint> +#include <QtCore/QRect> + +QT_BEGIN_NAMESPACE + +class QDesignerContainerExtension; +class QDesignerMetaDataBaseItemInterface; +class QDesignerMenu; + +class QMenuBar; +class QStatusBar; +class QToolBar; +class QToolBox; +class QTabWidget; +class QTableWidget; +class QTableWidgetItem; +class QTreeWidget; +class QTreeWidgetItem; +class QListWidget; +class QListWidgetItem; +class QComboBox; +class QStackedWidget; +class QDockWidget; +class QMainWindow; +class QFormLayout; + +namespace qdesigner_internal { + +class Layout; +class LayoutHelper; +class PropertySheetIconValue; +class DesignerIconCache; +struct LayoutProperties; + +class QDESIGNER_SHARED_EXPORT InsertWidgetCommand: public QDesignerFormWindowCommand +{ + +public: + explicit InsertWidgetCommand(QDesignerFormWindowInterface *formWindow); + ~InsertWidgetCommand(); + + void init(QWidget *widget, bool already_in_form = false, int layoutRow = -1, int layoutColumn = -1); + + virtual void redo(); + virtual void undo(); + +private: + void refreshBuddyLabels(); + + QPointer<QWidget> m_widget; + QDesignerLayoutDecorationExtension::InsertMode m_insertMode; + QPair<int, int> m_cell; + LayoutHelper* m_layoutHelper; + bool m_widgetWasManaged; +}; + +class QDESIGNER_SHARED_EXPORT ChangeZOrderCommand: public QDesignerFormWindowCommand +{ + +public: + explicit ChangeZOrderCommand(QDesignerFormWindowInterface *formWindow); + + void init(QWidget *widget); + + virtual void redo(); + virtual void undo(); +protected: + virtual QWidgetList reorderWidget(const QWidgetList &list, QWidget *widget) const = 0; + virtual void reorder(QWidget *widget) const = 0; + +private: + QPointer<QWidget> m_widget; + QPointer<QWidget> m_oldPreceding; + QList<QWidget *> m_oldParentZOrder; +}; + +class QDESIGNER_SHARED_EXPORT RaiseWidgetCommand: public ChangeZOrderCommand +{ + +public: + explicit RaiseWidgetCommand(QDesignerFormWindowInterface *formWindow); + + void init(QWidget *widget); + +protected: + virtual QWidgetList reorderWidget(const QWidgetList &list, QWidget *widget) const; + virtual void reorder(QWidget *widget) const; +}; + +class QDESIGNER_SHARED_EXPORT LowerWidgetCommand: public ChangeZOrderCommand +{ + +public: + explicit LowerWidgetCommand(QDesignerFormWindowInterface *formWindow); + + void init(QWidget *widget); + +protected: + virtual QWidgetList reorderWidget(const QWidgetList &list, QWidget *widget) const; + virtual void reorder(QWidget *widget) const; +}; + +class QDESIGNER_SHARED_EXPORT AdjustWidgetSizeCommand: public QDesignerFormWindowCommand +{ + +public: + explicit AdjustWidgetSizeCommand(QDesignerFormWindowInterface *formWindow); + + void init(QWidget *widget); + + virtual void redo(); + virtual void undo(); + +private: + QWidget *widgetForAdjust() const; + bool adjustNonLaidOutMainContainer(QWidget *integrationContainer); + void updatePropertyEditor() const; + + QPointer<QWidget> m_widget; + QRect m_geometry; +}; + +// Helper to correctly unmanage a widget and its children for delete operations +class QDESIGNER_SHARED_EXPORT ManageWidgetCommandHelper { +public: + typedef QVector<QWidget*> WidgetVector; + + ManageWidgetCommandHelper(); + void init(const QDesignerFormWindowInterface *fw, QWidget *widget); + void init(QWidget *widget, const WidgetVector &managedChildren); + + void manage(QDesignerFormWindowInterface *fw); + void unmanage(QDesignerFormWindowInterface *fw); + + const WidgetVector &managedChildren() const { return m_managedChildren; } +private: + QWidget *m_widget; + WidgetVector m_managedChildren; +}; + +class QDESIGNER_SHARED_EXPORT DeleteWidgetCommand: public QDesignerFormWindowCommand +{ + +public: + explicit DeleteWidgetCommand(QDesignerFormWindowInterface *formWindow); + ~DeleteWidgetCommand(); + + enum DeleteFlags { DoNotUnmanage = 0x1, DoNotSimplifyLayout = 0x2 }; + + void init(QWidget *widget, unsigned flags = 0); + + virtual void redo(); + virtual void undo(); + +private: + QPointer<QWidget> m_widget; + QPointer<QWidget> m_parentWidget; + QRect m_geometry; + LayoutInfo::Type m_layoutType; + LayoutHelper* m_layoutHelper; + unsigned m_flags; + QRect m_layoutPosition; + int m_splitterIndex; + bool m_layoutSimplified; + QDesignerMetaDataBaseItemInterface *m_formItem; + int m_tabOrderIndex; + int m_widgetOrderIndex; + int m_zOrderIndex; + ManageWidgetCommandHelper m_manageHelper; +}; + +class QDESIGNER_SHARED_EXPORT ReparentWidgetCommand: public QDesignerFormWindowCommand +{ + +public: + explicit ReparentWidgetCommand(QDesignerFormWindowInterface *formWindow); + + void init(QWidget *widget, QWidget *parentWidget); + + virtual void redo(); + virtual void undo(); + +private: + QPointer<QWidget> m_widget; + QPoint m_oldPos; + QPoint m_newPos; + QPointer<QWidget> m_oldParentWidget; + QPointer<QWidget> m_newParentWidget; + QList<QWidget *> m_oldParentList; + QList<QWidget *> m_oldParentZOrder; +}; + +class QDESIGNER_SHARED_EXPORT ChangeFormLayoutItemRoleCommand : public QDesignerFormWindowCommand +{ +public: + enum Operation { SpanningToLabel = 0x1, SpanningToField = 0x2, LabelToSpanning = 0x4, FieldToSpanning =0x8 }; + + explicit ChangeFormLayoutItemRoleCommand(QDesignerFormWindowInterface *formWindow); + + void init(QWidget *widget, Operation op); + + virtual void redo(); + virtual void undo(); + + // Return a mask of possible operations of that item + static unsigned possibleOperations(QDesignerFormEditorInterface *core, QWidget *w); + +private: + static QFormLayout *managedFormLayoutOf(QDesignerFormEditorInterface *core, QWidget *w); + static Operation reverseOperation(Operation op); + void doOperation(Operation op); + + QPointer<QWidget> m_widget; + Operation m_operation; +}; + +class QDESIGNER_SHARED_EXPORT ChangeLayoutItemGeometry: public QDesignerFormWindowCommand +{ + +public: + explicit ChangeLayoutItemGeometry(QDesignerFormWindowInterface *formWindow); + + void init(QWidget *widget, int row, int column, int rowspan, int colspan); + + virtual void redo(); + virtual void undo(); + +protected: + void changeItemPosition(const QRect &g); + +private: + QPointer<QWidget> m_widget; + QRect m_oldInfo; + QRect m_newInfo; +}; + +class QDESIGNER_SHARED_EXPORT TabOrderCommand: public QDesignerFormWindowCommand +{ + +public: + explicit TabOrderCommand(QDesignerFormWindowInterface *formWindow); + + void init(const QList<QWidget*> &newTabOrder); + + inline QList<QWidget*> oldTabOrder() const + { return m_oldTabOrder; } + + inline QList<QWidget*> newTabOrder() const + { return m_newTabOrder; } + + virtual void redo(); + virtual void undo(); + +private: + QDesignerMetaDataBaseItemInterface *m_widgetItem; + QList<QWidget*> m_oldTabOrder; + QList<QWidget*> m_newTabOrder; +}; + +class QDESIGNER_SHARED_EXPORT PromoteToCustomWidgetCommand : public QDesignerFormWindowCommand +{ +public: + typedef QList<QPointer<QWidget> > WidgetList; + + explicit PromoteToCustomWidgetCommand(QDesignerFormWindowInterface *formWindow); + + void init(const WidgetList &widgets, const QString &customClassName); + virtual void redo(); + virtual void undo(); + +private: + void updateSelection(); + WidgetList m_widgets; + QString m_customClassName; +}; + +class QDESIGNER_SHARED_EXPORT DemoteFromCustomWidgetCommand : public QDesignerFormWindowCommand +{ +public: + typedef PromoteToCustomWidgetCommand::WidgetList WidgetList; + + explicit DemoteFromCustomWidgetCommand(QDesignerFormWindowInterface *formWindow); + + void init(const WidgetList &promoted); + virtual void redo(); + virtual void undo(); +private: + PromoteToCustomWidgetCommand m_promote_cmd; +}; + +// Mixin class for storing the selection state +class QDESIGNER_SHARED_EXPORT CursorSelectionState { + Q_DISABLE_COPY(CursorSelectionState) +public: + CursorSelectionState(); + + void save(const QDesignerFormWindowInterface *formWindow); + void restore(QDesignerFormWindowInterface *formWindow) const; + +private: + typedef QList<QPointer<QWidget> > WidgetPointerList; + WidgetPointerList m_selection; + QPointer<QWidget> m_current; +}; + +class QDESIGNER_SHARED_EXPORT LayoutCommand: public QDesignerFormWindowCommand +{ + +public: + explicit LayoutCommand(QDesignerFormWindowInterface *formWindow); + virtual ~LayoutCommand(); + + inline QWidgetList widgets() const { return m_widgets; } + + void init(QWidget *parentWidget, const QWidgetList &widgets, LayoutInfo::Type layoutType, + QWidget *layoutBase = 0, + // Reparent/Hide instances of QLayoutWidget. + bool reparentLayoutWidget = true); + + virtual void redo(); + virtual void undo(); + +private: + QPointer<QWidget> m_parentWidget; + QWidgetList m_widgets; + QPointer<QWidget> m_layoutBase; + QPointer<Layout> m_layout; + CursorSelectionState m_cursorSelectionState; + bool m_setup; +}; + +class QDESIGNER_SHARED_EXPORT BreakLayoutCommand: public QDesignerFormWindowCommand +{ + +public: + explicit BreakLayoutCommand(QDesignerFormWindowInterface *formWindow); + virtual ~BreakLayoutCommand(); + + inline QWidgetList widgets() const { return m_widgets; } + + void init(const QWidgetList &widgets, QWidget *layoutBase, + // Reparent/Hide instances of QLayoutWidget. + bool reparentLayoutWidget = true); + + virtual void redo(); + virtual void undo(); + + // Access the properties of the layout, 0 in case of splitters. + const LayoutProperties *layoutProperties() const; + int propertyMask() const; + +private: + QWidgetList m_widgets; + QPointer<QWidget> m_layoutBase; + QPointer<Layout> m_layout; + LayoutHelper* m_layoutHelper; + LayoutProperties *m_properties; + int m_propertyMask; + CursorSelectionState m_cursorSelectionState; +}; + +class QDESIGNER_SHARED_EXPORT SimplifyLayoutCommand: public QDesignerFormWindowCommand +{ +public: + explicit SimplifyLayoutCommand(QDesignerFormWindowInterface *formWindow); + virtual ~SimplifyLayoutCommand(); + + bool init(QWidget *layoutBase); + + // Quick check + static bool canSimplify(QDesignerFormEditorInterface *core, const QWidget *w, int *layoutType = 0); + + virtual void redo(); + virtual void undo(); + +private: + const QRect m_area; + QWidget *m_layoutBase; + LayoutHelper* m_layoutHelper; + bool m_layoutSimplified; +}; + +class QDESIGNER_SHARED_EXPORT ToolBoxCommand: public QDesignerFormWindowCommand +{ + +public: + explicit ToolBoxCommand(QDesignerFormWindowInterface *formWindow); + virtual ~ToolBoxCommand(); + + void init(QToolBox *toolBox); + + virtual void removePage(); + virtual void addPage(); + +protected: + QPointer<QToolBox> m_toolBox; + QPointer<QWidget> m_widget; + int m_index; + QString m_itemText; + QIcon m_itemIcon; +}; + +class QDESIGNER_SHARED_EXPORT MoveToolBoxPageCommand: public ToolBoxCommand +{ + +public: + explicit MoveToolBoxPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~MoveToolBoxPageCommand(); + + void init(QToolBox *toolBox, QWidget *page, int newIndex); + + virtual void redo(); + virtual void undo(); + +private: + int m_newIndex; + int m_oldIndex; +}; + +class QDESIGNER_SHARED_EXPORT DeleteToolBoxPageCommand: public ToolBoxCommand +{ + +public: + explicit DeleteToolBoxPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~DeleteToolBoxPageCommand(); + + void init(QToolBox *toolBox); + + virtual void redo(); + virtual void undo(); +}; + +class QDESIGNER_SHARED_EXPORT AddToolBoxPageCommand: public ToolBoxCommand +{ + +public: + enum InsertionMode { + InsertBefore, + InsertAfter + }; + explicit AddToolBoxPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~AddToolBoxPageCommand(); + + void init(QToolBox *toolBox); + void init(QToolBox *toolBox, InsertionMode mode); + + virtual void redo(); + virtual void undo(); +}; + +class QDESIGNER_SHARED_EXPORT TabWidgetCommand: public QDesignerFormWindowCommand +{ + +public: + explicit TabWidgetCommand(QDesignerFormWindowInterface *formWindow); + virtual ~TabWidgetCommand(); + + void init(QTabWidget *tabWidget); + + virtual void removePage(); + virtual void addPage(); + +protected: + QPointer<QTabWidget> m_tabWidget; + QPointer<QWidget> m_widget; + int m_index; + QString m_itemText; + QIcon m_itemIcon; +}; + +class QDESIGNER_SHARED_EXPORT DeleteTabPageCommand: public TabWidgetCommand +{ + +public: + explicit DeleteTabPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~DeleteTabPageCommand(); + + void init(QTabWidget *tabWidget); + + virtual void redo(); + virtual void undo(); +}; + +class QDESIGNER_SHARED_EXPORT AddTabPageCommand: public TabWidgetCommand +{ + +public: + enum InsertionMode { + InsertBefore, + InsertAfter + }; + explicit AddTabPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~AddTabPageCommand(); + + void init(QTabWidget *tabWidget); + void init(QTabWidget *tabWidget, InsertionMode mode); + + virtual void redo(); + virtual void undo(); +}; + +class QDESIGNER_SHARED_EXPORT MoveTabPageCommand: public TabWidgetCommand +{ + +public: + explicit MoveTabPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~MoveTabPageCommand(); + + void init(QTabWidget *tabWidget, QWidget *page, + const QIcon &icon, const QString &label, + int index, int newIndex); + + virtual void redo(); + virtual void undo(); + +private: + int m_newIndex; + int m_oldIndex; + QPointer<QWidget> m_page; + QString m_label; + QIcon m_icon; +}; + +class QDESIGNER_SHARED_EXPORT StackedWidgetCommand: public QDesignerFormWindowCommand +{ + +public: + explicit StackedWidgetCommand(QDesignerFormWindowInterface *formWindow); + virtual ~StackedWidgetCommand(); + + void init(QStackedWidget *stackedWidget); + + virtual void removePage(); + virtual void addPage(); + +protected: + QPointer<QStackedWidget> m_stackedWidget; + QPointer<QWidget> m_widget; + int m_index; +}; + +class QDESIGNER_SHARED_EXPORT MoveStackedWidgetCommand: public StackedWidgetCommand +{ + +public: + explicit MoveStackedWidgetCommand(QDesignerFormWindowInterface *formWindow); + virtual ~MoveStackedWidgetCommand(); + + void init(QStackedWidget *stackedWidget, QWidget *page, int newIndex); + + virtual void redo(); + virtual void undo(); + +private: + int m_newIndex; + int m_oldIndex; +}; + +class QDESIGNER_SHARED_EXPORT DeleteStackedWidgetPageCommand: public StackedWidgetCommand +{ + +public: + explicit DeleteStackedWidgetPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~DeleteStackedWidgetPageCommand(); + + void init(QStackedWidget *stackedWidget); + + virtual void redo(); + virtual void undo(); +}; + +class QDESIGNER_SHARED_EXPORT AddStackedWidgetPageCommand: public StackedWidgetCommand +{ + +public: + enum InsertionMode { + InsertBefore, + InsertAfter + }; + explicit AddStackedWidgetPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~AddStackedWidgetPageCommand(); + + void init(QStackedWidget *stackedWidget); + void init(QStackedWidget *stackedWidget, InsertionMode mode); + + virtual void redo(); + virtual void undo(); +}; + +class QDESIGNER_SHARED_EXPORT CreateMenuBarCommand: public QDesignerFormWindowCommand +{ + +public: + explicit CreateMenuBarCommand(QDesignerFormWindowInterface *formWindow); + + void init(QMainWindow *mainWindow); + + virtual void undo(); + virtual void redo(); + +private: + QPointer<QMainWindow> m_mainWindow; + QPointer<QMenuBar> m_menuBar; +}; + +class QDESIGNER_SHARED_EXPORT DeleteMenuBarCommand: public QDesignerFormWindowCommand +{ + +public: + explicit DeleteMenuBarCommand(QDesignerFormWindowInterface *formWindow); + + void init(QMenuBar *menuBar); + + virtual void undo(); + virtual void redo(); + +private: + QPointer<QMainWindow> m_mainWindow; + QPointer<QMenuBar> m_menuBar; +}; + +class QDESIGNER_SHARED_EXPORT CreateStatusBarCommand: public QDesignerFormWindowCommand +{ + +public: + explicit CreateStatusBarCommand(QDesignerFormWindowInterface *formWindow); + + void init(QMainWindow *mainWindow); + + virtual void undo(); + virtual void redo(); + +private: + QPointer<QMainWindow> m_mainWindow; + QPointer<QStatusBar> m_statusBar; +}; + +class QDESIGNER_SHARED_EXPORT DeleteStatusBarCommand: public QDesignerFormWindowCommand +{ + +public: + explicit DeleteStatusBarCommand(QDesignerFormWindowInterface *formWindow); + + void init(QStatusBar *statusBar); + + virtual void undo(); + virtual void redo(); + +private: + QPointer<QMainWindow> m_mainWindow; + QPointer<QStatusBar> m_statusBar; +}; + +class QDESIGNER_SHARED_EXPORT AddToolBarCommand: public QDesignerFormWindowCommand +{ + +public: + explicit AddToolBarCommand(QDesignerFormWindowInterface *formWindow); + + void init(QMainWindow *mainWindow); + + virtual void undo(); + virtual void redo(); + +private: + QPointer<QMainWindow> m_mainWindow; + QPointer<QToolBar> m_toolBar; +}; + +class QDESIGNER_SHARED_EXPORT DeleteToolBarCommand: public QDesignerFormWindowCommand +{ + +public: + explicit DeleteToolBarCommand(QDesignerFormWindowInterface *formWindow); + + void init(QToolBar *toolBar); + + virtual void undo(); + virtual void redo(); + +private: + QPointer<QMainWindow> m_mainWindow; + QPointer<QToolBar> m_toolBar; +}; + +class QDESIGNER_SHARED_EXPORT DockWidgetCommand: public QDesignerFormWindowCommand +{ + +public: + explicit DockWidgetCommand(const QString &description, QDesignerFormWindowInterface *formWindow); + virtual ~DockWidgetCommand(); + + void init(QDockWidget *dockWidget); + +protected: + QPointer<QDockWidget> m_dockWidget; +}; + +class QDESIGNER_SHARED_EXPORT AddDockWidgetCommand: public QDesignerFormWindowCommand +{ + +public: + explicit AddDockWidgetCommand(QDesignerFormWindowInterface *formWindow); + + void init(QMainWindow *mainWindow, QDockWidget *dockWidget); + void init(QMainWindow *mainWindow); + + virtual void undo(); + virtual void redo(); + +private: + QPointer<QMainWindow> m_mainWindow; + QPointer<QDockWidget> m_dockWidget; +}; + +class QDESIGNER_SHARED_EXPORT ContainerWidgetCommand: public QDesignerFormWindowCommand +{ + +public: + explicit ContainerWidgetCommand(QDesignerFormWindowInterface *formWindow); + virtual ~ContainerWidgetCommand(); + + QDesignerContainerExtension *containerExtension() const; + + void init(QWidget *containerWidget); + + virtual void removePage(); + virtual void addPage(); + +protected: + QPointer<QWidget> m_containerWidget; + QPointer<QWidget> m_widget; + int m_index; +}; + +class QDESIGNER_SHARED_EXPORT DeleteContainerWidgetPageCommand: public ContainerWidgetCommand +{ + +public: + explicit DeleteContainerWidgetPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~DeleteContainerWidgetPageCommand(); + + void init(QWidget *containerWidget, ContainerType ct); + + virtual void redo(); + virtual void undo(); +}; + +class QDESIGNER_SHARED_EXPORT AddContainerWidgetPageCommand: public ContainerWidgetCommand +{ + +public: + enum InsertionMode { + InsertBefore, + InsertAfter + }; + explicit AddContainerWidgetPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~AddContainerWidgetPageCommand(); + + void init(QWidget *containerWidget, ContainerType ct, InsertionMode mode); + + virtual void redo(); + virtual void undo(); +}; + +class QDESIGNER_SHARED_EXPORT ChangeCurrentPageCommand: public QDesignerFormWindowCommand +{ + +public: + explicit ChangeCurrentPageCommand(QDesignerFormWindowInterface *formWindow); + virtual ~ChangeCurrentPageCommand(); + + QDesignerContainerExtension *containerExtension() const; + + void init(QWidget *containerWidget, int newIndex); + + virtual void redo(); + virtual void undo(); + +protected: + QPointer<QWidget> m_containerWidget; + QPointer<QWidget> m_widget; + int m_oldIndex; + int m_newIndex; +}; + +struct QDESIGNER_SHARED_EXPORT ItemData { + ItemData() {} + + ItemData(const QListWidgetItem *item, bool editor); + ItemData(const QTableWidgetItem *item, bool editor); + ItemData(const QTreeWidgetItem *item, int column); + QListWidgetItem *createListItem(DesignerIconCache *iconCache, bool editor) const; + QTableWidgetItem *createTableItem(DesignerIconCache *iconCache, bool editor) const; + void fillTreeItemColumn(QTreeWidgetItem *item, int column, DesignerIconCache *iconCache) const; + + bool isValid() const { return !m_properties.isEmpty(); } + bool operator==(const ItemData &rhs) const { return m_properties == rhs.m_properties; } + bool operator!=(const ItemData &rhs) const { return m_properties != rhs.m_properties; } + + QHash<int, QVariant> m_properties; +}; + +struct QDESIGNER_SHARED_EXPORT ListContents { + ListContents() {} + + ListContents(const QTreeWidgetItem *item); + QTreeWidgetItem *createTreeItem(DesignerIconCache *iconCache) const; + + void createFromListWidget(const QListWidget *listWidget, bool editor); + void applyToListWidget(QListWidget *listWidget, DesignerIconCache *iconCache, bool editor) const; + void createFromComboBox(const QComboBox *listWidget); + void applyToComboBox(QComboBox *listWidget, DesignerIconCache *iconCache) const; + + bool operator==(const ListContents &rhs) const { return m_items == rhs.m_items; } + bool operator!=(const ListContents &rhs) const { return m_items != rhs.m_items; } + + QList<ItemData> m_items; +}; + +// Data structure representing the contents of a QTableWidget with +// methods to retrieve and apply for ChangeTableContentsCommand +struct QDESIGNER_SHARED_EXPORT TableWidgetContents { + + typedef QPair<int, int> CellRowColumnAddress; + typedef QMap<CellRowColumnAddress, ItemData> TableItemMap; + + TableWidgetContents(); + void clear(); + + void fromTableWidget(const QTableWidget *tableWidget, bool editor); + void applyToTableWidget(QTableWidget *tableWidget, DesignerIconCache *iconCache, bool editor) const; + + bool operator==(const TableWidgetContents &rhs) const; + bool operator!=(const TableWidgetContents &rhs) const { return !(*this == rhs); } + + static bool nonEmpty(const QTableWidgetItem *item, int headerColumn); + static QString defaultHeaderText(int i); + static void insertHeaderItem(const QTableWidgetItem *item, int i, ListContents *header, bool editor); + + int m_columnCount; + int m_rowCount; + ListContents m_horizontalHeader; + ListContents m_verticalHeader; + TableItemMap m_items; +}; + +class QDESIGNER_SHARED_EXPORT ChangeTableContentsCommand: public QDesignerFormWindowCommand +{ +public: + explicit ChangeTableContentsCommand(QDesignerFormWindowInterface *formWindow); + + void init(QTableWidget *tableWidget, const TableWidgetContents &oldCont, const TableWidgetContents &newCont); + virtual void redo(); + virtual void undo(); + +private: + QPointer<QTableWidget> m_tableWidget; + TableWidgetContents m_oldContents; + TableWidgetContents m_newContents; + DesignerIconCache *m_iconCache; +}; + +// Data structure representing the contents of a QTreeWidget with +// methods to retrieve and apply for ChangeTreeContentsCommand +struct QDESIGNER_SHARED_EXPORT TreeWidgetContents { + + struct ItemContents : public ListContents { + ItemContents() : m_itemFlags(-1) {} + ItemContents(const QTreeWidgetItem *item, bool editor); + QTreeWidgetItem *createTreeItem(DesignerIconCache *iconCache, bool editor) const; + + bool operator==(const ItemContents &rhs) const; + bool operator!=(const ItemContents &rhs) const { return !(*this == rhs); } + + int m_itemFlags; + //bool m_firstColumnSpanned:1; + //bool m_hidden:1; + //bool m_expanded:1; + QList<ItemContents> m_children; + }; + + void clear(); + + void fromTreeWidget(const QTreeWidget *treeWidget, bool editor); + void applyToTreeWidget(QTreeWidget *treeWidget, DesignerIconCache *iconCache, bool editor) const; + + bool operator==(const TreeWidgetContents &rhs) const; + bool operator!=(const TreeWidgetContents &rhs) const { return !(*this == rhs); } + + ListContents m_headerItem; + QList<ItemContents> m_rootItems; +}; + +class QDESIGNER_SHARED_EXPORT ChangeTreeContentsCommand: public QDesignerFormWindowCommand +{ + +public: + explicit ChangeTreeContentsCommand(QDesignerFormWindowInterface *formWindow); + + void init(QTreeWidget *treeWidget, const TreeWidgetContents &oldState, const TreeWidgetContents &newState); + virtual void redo(); + virtual void undo(); + enum ApplyIconStrategy { + SetIconStrategy, + ResetIconStrategy + }; +private: + QPointer<QTreeWidget> m_treeWidget; + TreeWidgetContents m_oldState; + TreeWidgetContents m_newState; + DesignerIconCache *m_iconCache; +}; + +class QDESIGNER_SHARED_EXPORT ChangeListContentsCommand: public QDesignerFormWindowCommand +{ + +public: + explicit ChangeListContentsCommand(QDesignerFormWindowInterface *formWindow); + + void init(QListWidget *listWidget, const ListContents &oldItems, const ListContents &items); + void init(QComboBox *comboBox, const ListContents &oldItems, const ListContents &items); + virtual void redo(); + virtual void undo(); +private: + QPointer<QListWidget> m_listWidget; + QPointer<QComboBox> m_comboBox; + ListContents m_oldItemsState; + ListContents m_newItemsState; + DesignerIconCache *m_iconCache; +}; + +class QDESIGNER_SHARED_EXPORT AddActionCommand : public QDesignerFormWindowCommand +{ + +public: + explicit AddActionCommand(QDesignerFormWindowInterface *formWindow); + void init(QAction *action); + virtual void redo(); + virtual void undo(); +private: + QAction *m_action; +}; + +// Note: This command must be executed within a macro since it +// makes the form emit objectRemoved() which might cause other components +// to add commands (for example, removal of signals and slots +class QDESIGNER_SHARED_EXPORT RemoveActionCommand : public QDesignerFormWindowCommand +{ + +public: + explicit RemoveActionCommand(QDesignerFormWindowInterface *formWindow); + void init(QAction *action); + virtual void redo(); + virtual void undo(); + + struct ActionDataItem { + ActionDataItem(QAction *_before = 0, QWidget *_widget = 0) + : before(_before), widget(_widget) {} + QAction *before; + QWidget *widget; + }; + typedef QList<ActionDataItem> ActionData; + +private: + QAction *m_action; + + ActionData m_actionData; +}; + +class QDESIGNER_SHARED_EXPORT ActionInsertionCommand : public QDesignerFormWindowCommand +{ + +protected: + ActionInsertionCommand(const QString &text, QDesignerFormWindowInterface *formWindow); + +public: + void init(QWidget *parentWidget, QAction *action, QAction *beforeAction = 0, bool update = true); + +protected: + void insertAction(); + void removeAction(); + +private: + QWidget *m_parentWidget; + QAction *m_action; + QAction *m_beforeAction; + bool m_update; +}; + +class QDESIGNER_SHARED_EXPORT InsertActionIntoCommand : public ActionInsertionCommand +{ + +public: + explicit InsertActionIntoCommand(QDesignerFormWindowInterface *formWindow); + + virtual void redo() { insertAction(); } + virtual void undo() { removeAction(); } +}; + +class QDESIGNER_SHARED_EXPORT RemoveActionFromCommand : public ActionInsertionCommand +{ + +public: + explicit RemoveActionFromCommand(QDesignerFormWindowInterface *formWindow); + + virtual void redo() { removeAction(); } + virtual void undo() { insertAction(); } +}; + +class QDESIGNER_SHARED_EXPORT MenuActionCommand : public QDesignerFormWindowCommand +{ +public: + void init(QAction *action, QAction *actionBefore, QWidget *associatedWidget, QWidget *objectToSelect); + +protected: + MenuActionCommand(const QString &text, QDesignerFormWindowInterface *formWindow); + void insertMenu(); + void removeMenu(); + +private: + QAction *m_action; + QAction *m_actionBefore; + QWidget *m_menuParent; + QWidget *m_associatedWidget; + QWidget *m_objectToSelect; +}; + +class QDESIGNER_SHARED_EXPORT AddMenuActionCommand : public MenuActionCommand +{ + +public: + explicit AddMenuActionCommand(QDesignerFormWindowInterface *formWindow); + + virtual void redo() { insertMenu(); } + virtual void undo() { removeMenu(); } +}; + +class QDESIGNER_SHARED_EXPORT RemoveMenuActionCommand : public MenuActionCommand +{ + +public: + explicit RemoveMenuActionCommand(QDesignerFormWindowInterface *formWindow); + + virtual void redo() { removeMenu(); } + virtual void undo() { insertMenu(); } +}; + +class QDESIGNER_SHARED_EXPORT CreateSubmenuCommand : public QDesignerFormWindowCommand +{ + +public: + explicit CreateSubmenuCommand(QDesignerFormWindowInterface *formWindow); + void init(QDesignerMenu *menu, QAction *action, QObject *m_objectToSelect = 0); + virtual void redo(); + virtual void undo(); +private: + QAction *m_action; + QDesignerMenu *m_menu; + QObject *m_objectToSelect; +}; + +} // namespace qdesigner_internal + +QT_END_NAMESPACE + +#endif // QDESIGNER_COMMAND_H |