Initial import from the monolithic Qt.

This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:

http://qt.gitorious.org/qt/pages/GitIntroductionWithQt

If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.

Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12

45 files changed, 7092 insertions, 0 deletions

diff --git a/src/designer/src/components/taskmenu/button_taskmenu.cpp b/src/designer/src/components/taskmenu/button_taskmenu.cpp
new file mode 100644
index 000000000..953996b8c
--- /dev/null
+++ b/src/designer/src/components/taskmenu/button_taskmenu.cpp
@@ -0,0 +1,709 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "button_taskmenu.h"
+#include "inplace_editor.h"
+#include <qdesigner_formwindowcommand_p.h>
+#include <formwindowbase_p.h>
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+#include <QtDesigner/QDesignerFormWindowCursorInterface>
+#include <QtDesigner/QDesignerFormEditorInterface>
+#include <QtDesigner/QDesignerMetaDataBaseInterface>
+#include <QtDesigner/QDesignerObjectInspectorInterface>
+#include <QtDesigner/QDesignerPropertyEditorInterface>
+
+#include <QtGui/QAction>
+#include <QtGui/QActionGroup>
+#include <QtGui/QMenu>
+#include <QtGui/QStyle>
+#include <QtGui/QStyleOption>
+#include <QtGui/QAbstractButton>
+#include <QtGui/QButtonGroup>
+#include <QtGui/QApplication>
+#include <QtCore/QDebug>
+
+Q_DECLARE_METATYPE(QButtonGroup*)
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+enum { debugButtonMenu = 0 };
+
+typedef QList<QAbstractButton *> ButtonList;
+typedef QList<QButtonGroup *> ButtonGroupList;
+
+// ButtonGroupCommand: Base for commands handling button groups and button lists
+// addButtonsToGroup() and removeButtonsFromGroup() are low-level helpers for
+// adding/removing members to/from existing groups.
+//
+// createButtonGroup()/breakButtonGroup() create and remove the groups from scratch.
+// When using them in a command, the 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 ButtonGroupCommand : public QDesignerFormWindowCommand {
+
+protected:
+    ButtonGroupCommand(const QString &description, QDesignerFormWindowInterface *formWindow);
+
+    void initialize(const ButtonList &bl, QButtonGroup *buttonGroup);
+
+    // Helper: Add the buttons to the group
+    void addButtonsToGroup();
+    // Helper; Remove the buttons
+    void removeButtonsFromGroup();
+
+    // Create the button group in Designer
+    void createButtonGroup();
+    // Remove the button group from Designer
+    void breakButtonGroup();
+
+public:
+    static QString nameList(const ButtonList& bl);
+    static ButtonGroupList managedButtonGroups(const QDesignerFormWindowInterface *formWindow);
+
+private:
+    ButtonList m_buttonList;
+    QButtonGroup *m_buttonGroup;
+};
+
+ButtonGroupCommand::ButtonGroupCommand(const QString &description, QDesignerFormWindowInterface *formWindow) :
+    QDesignerFormWindowCommand(description, formWindow),
+    m_buttonGroup(0)
+{
+}
+
+void ButtonGroupCommand::initialize(const ButtonList &bl, QButtonGroup *buttonGroup)
+{
+    m_buttonList = bl;
+    m_buttonGroup = buttonGroup;
+}
+
+void ButtonGroupCommand::addButtonsToGroup()
+{
+    if (debugButtonMenu)
+        qDebug() << "Adding " << m_buttonList << " to " << m_buttonGroup;
+    const ButtonList::const_iterator cend = m_buttonList.constEnd();
+    for (ButtonList::const_iterator it = m_buttonList.constBegin(); it != cend; ++it)
+        m_buttonGroup->addButton(*it);
+}
+
+void ButtonGroupCommand::removeButtonsFromGroup()
+{
+    if (debugButtonMenu)
+        qDebug() << "Removing " << m_buttonList << " from " << m_buttonGroup;
+    const ButtonList::const_iterator cend = m_buttonList.constEnd();
+    for (ButtonList::const_iterator it = m_buttonList.constBegin(); it != cend; ++it)
+        m_buttonGroup->removeButton(*it);
+}
+
+void ButtonGroupCommand::createButtonGroup()
+{
+    if (debugButtonMenu)
+        qDebug() << "Creating " <<  m_buttonGroup << " from " <<  m_buttonList;
+
+    QDesignerFormWindowInterface *fw = formWindow();
+    QDesignerFormEditorInterface *core = fw->core();
+    core->metaDataBase()->add(m_buttonGroup);
+    addButtonsToGroup();
+    // Make button group visible
+    core->objectInspector()->setFormWindow(fw);
+}
+
+void ButtonGroupCommand::breakButtonGroup()
+{
+    if (debugButtonMenu)
+        qDebug() << "Removing " <<  m_buttonGroup << " consisting of " <<  m_buttonList;
+
+    QDesignerFormWindowInterface *fw = formWindow();
+    QDesignerFormEditorInterface *core = fw->core();
+    // Button group was selected, that is, break was invoked via its context menu. Remove it from property editor, select the buttons
+    if (core->propertyEditor()->object() == m_buttonGroup) {
+        fw->clearSelection(false);
+        const ButtonList::const_iterator cend = m_buttonList.constEnd();
+        for (ButtonList::const_iterator it = m_buttonList.constBegin(); it != cend; ++it)
+            fw->selectWidget(*it, true);
+    }
+    // Now remove and refresh object inspector
+    removeButtonsFromGroup();
+    // Notify components (for example, signal slot editor)
+    if (qdesigner_internal::FormWindowBase *fwb = qobject_cast<qdesigner_internal::FormWindowBase *>(fw))
+        fwb->emitObjectRemoved(m_buttonGroup);
+    core->metaDataBase()->remove(m_buttonGroup);
+    core->objectInspector()->setFormWindow(fw);
+}
+
+QString ButtonGroupCommand::nameList(const ButtonList& bl)
+{
+    QString rc;
+    const QChar quote = QLatin1Char('\'');
+    const QString separator =  QLatin1String(", ");
+    const int size = bl.size();
+    for (int i = 0; i < size; i++) {
+        if (i)
+            rc += separator;
+        rc += quote;
+        rc += bl[i]->objectName();
+        rc += quote;
+    }
+    return rc;
+
+}
+
+ButtonGroupList ButtonGroupCommand::managedButtonGroups(const QDesignerFormWindowInterface *formWindow)
+{
+    const QDesignerMetaDataBaseInterface *mdb = formWindow->core()->metaDataBase();
+    ButtonGroupList bl;
+    // Check 1st order children for managed button groups
+    const QObjectList children = formWindow->mainContainer()->children();
+    const QObjectList::const_iterator cend =  children.constEnd();
+    for (QObjectList::const_iterator it =  children.constBegin(); it != cend; ++it) {
+        if (!(*it)->isWidgetType())
+            if (QButtonGroup *bg = qobject_cast<QButtonGroup *>(*it))
+                if (mdb->item(bg))
+                    bl.push_back(bg);
+    }
+    return bl;
+}
+
+// --------------- CreateButtonGroupCommand
+// This command might be executed in a macro with a remove
+// command to move buttons from one group to a new one.
+class CreateButtonGroupCommand : public ButtonGroupCommand {
+public:
+    CreateButtonGroupCommand(QDesignerFormWindowInterface *formWindow);
+    bool init(const ButtonList &bl);
+
+    virtual void undo() { breakButtonGroup(); }
+    virtual void redo() { createButtonGroup(); }
+};
+
+CreateButtonGroupCommand::CreateButtonGroupCommand(QDesignerFormWindowInterface *formWindow) :
+    ButtonGroupCommand(QApplication::translate("Command", "Create button group"), formWindow)
+{
+}
+
+bool CreateButtonGroupCommand::init(const ButtonList &bl)
+{
+    if (bl.empty())
+        return false;
+    QDesignerFormWindowInterface *fw = formWindow();
+    QButtonGroup *buttonGroup = new QButtonGroup(fw->mainContainer());
+    buttonGroup->setObjectName(QLatin1String("buttonGroup"));
+    fw->ensureUniqueObjectName(buttonGroup);
+    initialize(bl, buttonGroup);
+    return true;
+}
+
+// --------------- BreakButtonGroupCommand
+class BreakButtonGroupCommand : public ButtonGroupCommand {
+public:
+    BreakButtonGroupCommand(QDesignerFormWindowInterface *formWindow);
+    bool init(QButtonGroup *group);
+
+    virtual void undo() { createButtonGroup(); }
+    virtual void redo() { breakButtonGroup(); }
+};
+
+BreakButtonGroupCommand::BreakButtonGroupCommand(QDesignerFormWindowInterface *formWindow) :
+    ButtonGroupCommand(QApplication::translate("Command", "Break button group"), formWindow)
+{
+}
+
+bool BreakButtonGroupCommand::init(QButtonGroup *group)
+{
+    if (!group)
+        return false;
+    initialize(group->buttons(), group);
+    setText(QApplication::translate("Command", "Break button group '%1'").arg(group->objectName()));
+    return true;
+}
+
+// --------------- AddButtonsToGroupCommand
+// This command might be executed in a macro with a remove
+// command to move buttons from one group to a new one.
+class AddButtonsToGroupCommand : public ButtonGroupCommand {
+public:
+    AddButtonsToGroupCommand(QDesignerFormWindowInterface *formWindow);
+    void init(const ButtonList &bl, QButtonGroup *group);
+
+    virtual void undo() { removeButtonsFromGroup(); }
+    virtual void redo() { addButtonsToGroup(); }
+};
+
+AddButtonsToGroupCommand::AddButtonsToGroupCommand(QDesignerFormWindowInterface *formWindow) :
+    ButtonGroupCommand(QApplication::translate("Command", "Add buttons to group"), formWindow)
+{
+}
+
+void AddButtonsToGroupCommand::init(const ButtonList &bl, QButtonGroup *group)
+{
+    initialize(bl, group);
+    //: Command description for adding buttons to a QButtonGroup
+    setText(QApplication::translate("Command", "Add '%1' to '%2'").arg(nameList(bl), group->objectName()));
+}
+
+//--------------------  RemoveButtonsFromGroupCommand
+class RemoveButtonsFromGroupCommand : public ButtonGroupCommand {
+public:
+    RemoveButtonsFromGroupCommand(QDesignerFormWindowInterface *formWindow);
+    bool init(const ButtonList &bl);
+
+    virtual void undo() {  addButtonsToGroup(); }
+    virtual void redo() {  removeButtonsFromGroup(); }
+};
+
+RemoveButtonsFromGroupCommand::RemoveButtonsFromGroupCommand(QDesignerFormWindowInterface *formWindow) :
+    ButtonGroupCommand(QApplication::translate("Command", "Remove buttons from group"), formWindow)
+{
+}
+
+bool RemoveButtonsFromGroupCommand::init(const ButtonList &bl)
+{
+    if (bl.empty())
+        return false;
+    QButtonGroup *group = bl.front()->group();
+    if (!group)
+        return false;
+    if (bl.size() >= group->buttons().size())
+        return false;
+    initialize(bl, group);
+    //: Command description for removing buttons from a QButtonGroup
+    setText(QApplication::translate("Command", "Remove '%1' from '%2'").arg(nameList(bl), group->objectName()));
+    return true;
+}
+
+// --------  ButtonGroupMenu
+ButtonGroupMenu::ButtonGroupMenu(QObject *parent) :
+    QObject(parent),
+    m_selectGroupAction(new QAction(tr("Select members"), this)),
+    m_breakGroupAction(new QAction(tr("Break"), this)),
+    m_formWindow(0),
+    m_buttonGroup(0),
+    m_currentButton(0)
+{
+    connect(m_breakGroupAction, SIGNAL(triggered()), this, SLOT(breakGroup()));
+    connect(m_selectGroupAction, SIGNAL(triggered()), this, SLOT(selectGroup()));
+}
+
+void ButtonGroupMenu::initialize(QDesignerFormWindowInterface *formWindow, QButtonGroup *buttonGroup, QAbstractButton *currentButton)
+{
+    m_buttonGroup = buttonGroup;
+    m_currentButton = currentButton;
+    m_formWindow = formWindow;
+    Q_ASSERT(m_formWindow);
+
+    const bool canBreak = buttonGroup != 0;
+    m_breakGroupAction->setEnabled(canBreak);
+    m_selectGroupAction->setEnabled(canBreak);
+}
+
+void ButtonGroupMenu::selectGroup()
+{
+    // Select and make current button "current" again by selecting it last (if there is any)
+    const ButtonList buttons = m_buttonGroup->buttons();
+    m_formWindow->clearSelection(false);
+    const ButtonList::const_iterator cend = buttons.constEnd();
+    for (ButtonList::const_iterator it = buttons.constBegin(); it != cend; ++it)
+        if (*it != m_currentButton)
+            m_formWindow->selectWidget(*it, true);
+    if (m_currentButton)
+        m_formWindow->selectWidget(m_currentButton, true);
+}
+
+void ButtonGroupMenu::breakGroup()
+{
+    BreakButtonGroupCommand *cmd = new BreakButtonGroupCommand(m_formWindow);
+    if (cmd->init(m_buttonGroup)) {
+        // Need a macro since the command might trigger additional commands
+        QUndoStack *history = m_formWindow->commandHistory();
+        history->beginMacro(cmd->text());
+        history->push(cmd);
+        history->endMacro();
+    } else {
+        qWarning("** WARNING Failed to initialize BreakButtonGroupCommand!");
+        delete cmd;
+    }
+}
+
+// ButtonGroupTaskMenu
+ButtonGroupTaskMenu::ButtonGroupTaskMenu(QButtonGroup *buttonGroup, QObject *parent) :
+    QObject(parent),
+    m_buttonGroup(buttonGroup)
+{
+    m_taskActions.push_back(m_menu.breakGroupAction());
+    m_taskActions.push_back(m_menu.selectGroupAction());
+}
+
+QAction *ButtonGroupTaskMenu::preferredEditAction() const
+{
+    return m_menu.selectGroupAction();
+}
+
+QList<QAction*> ButtonGroupTaskMenu::taskActions() const
+{
+    m_menu.initialize(QDesignerFormWindowInterface::findFormWindow(m_buttonGroup), m_buttonGroup);
+    return m_taskActions;
+}
+
+// -------- Text area editor
+class ButtonTextTaskMenuInlineEditor : public  TaskMenuInlineEditor
+{
+public:
+    ButtonTextTaskMenuInlineEditor(QAbstractButton *button, QObject *parent);
+
+protected:
+    virtual QRect editRectangle() const;
+};
+
+ButtonTextTaskMenuInlineEditor::ButtonTextTaskMenuInlineEditor(QAbstractButton *button, QObject *parent) :
+      TaskMenuInlineEditor(button, ValidationMultiLine, QLatin1String("text"), parent)
+{
+}
+
+QRect ButtonTextTaskMenuInlineEditor::editRectangle() const
+{
+    QWidget *w = widget();
+    QStyleOptionButton opt;
+    opt.init(w);
+    return w->style()->subElementRect(QStyle::SE_PushButtonContents, &opt, w);
+}
+
+// -------- Command link button description editor
+class LinkDescriptionTaskMenuInlineEditor : public  TaskMenuInlineEditor
+{
+public:
+    LinkDescriptionTaskMenuInlineEditor(QAbstractButton *button, QObject *parent);
+
+protected:
+    virtual QRect editRectangle() const;
+};
+
+LinkDescriptionTaskMenuInlineEditor::LinkDescriptionTaskMenuInlineEditor(QAbstractButton *button, QObject *parent) :
+      TaskMenuInlineEditor(button, ValidationMultiLine, QLatin1String("description"), parent)
+{
+}
+
+QRect LinkDescriptionTaskMenuInlineEditor::editRectangle() const
+{
+    QWidget *w = widget(); // TODO: What is the exact description area?
+    QStyleOptionButton opt;
+    opt.init(w);
+    return w->style()->subElementRect(QStyle::SE_PushButtonContents, &opt, w);
+}
+
+// ----------- ButtonTaskMenu:
+
+ButtonTaskMenu::ButtonTaskMenu(QAbstractButton *button, QObject *parent)  :
+    QDesignerTaskMenu(button, parent),
+    m_assignGroupSubMenu(new QMenu),
+    m_assignActionGroup(0),
+    m_assignToGroupSubMenuAction(new QAction(tr("Assign to button group"), this)),
+    m_currentGroupSubMenu(new QMenu),
+    m_currentGroupSubMenuAction(new QAction(tr("Button group"), this)),
+    m_createGroupAction(new QAction(tr("New button group"), this)),
+    m_preferredEditAction(new QAction(tr("Change text..."), this)),
+    m_removeFromGroupAction(new QAction(tr("None"), this))
+{
+    connect(m_createGroupAction, SIGNAL(triggered()), this, SLOT(createGroup()));
+    TaskMenuInlineEditor *textEditor = new ButtonTextTaskMenuInlineEditor(button, this);
+    connect(m_preferredEditAction, SIGNAL(triggered()), textEditor, SLOT(editText()));
+    connect(m_removeFromGroupAction, SIGNAL(triggered()), this, SLOT(removeFromGroup()));
+
+    m_assignToGroupSubMenuAction->setMenu(m_assignGroupSubMenu);
+
+    m_currentGroupSubMenu->addAction(m_groupMenu.breakGroupAction());
+    m_currentGroupSubMenu->addAction(m_groupMenu.selectGroupAction());
+    m_currentGroupSubMenuAction->setMenu(m_currentGroupSubMenu);
+
+
+    m_taskActions.append(m_preferredEditAction);
+    m_taskActions.append(m_assignToGroupSubMenuAction);
+    m_taskActions.append(m_currentGroupSubMenuAction);
+    m_taskActions.append(createSeparator());
+}
+
+ButtonTaskMenu::~ButtonTaskMenu()
+{
+    delete m_assignGroupSubMenu;
+    delete m_currentGroupSubMenu;
+}
+
+QAction *ButtonTaskMenu::preferredEditAction() const
+{
+    return m_preferredEditAction;
+}
+
+bool ButtonTaskMenu::refreshAssignMenu(const QDesignerFormWindowInterface *fw, int buttonCount, SelectionType st, QButtonGroup *currentGroup)
+{
+    // clear
+    if (m_assignActionGroup) {
+        delete m_assignActionGroup;
+        m_assignActionGroup = 0;
+    }
+    m_assignGroupSubMenu->clear();
+    if (st == OtherSelection)
+        return false;
+
+
+    // Assign to new: Need several
+    const bool canAssignToNewGroup = buttonCount > 1;
+    m_createGroupAction->setEnabled(canAssignToNewGroup);
+    if (canAssignToNewGroup)
+        m_assignGroupSubMenu->addAction(m_createGroupAction);
+
+    // Assign to other
+    const ButtonGroupList bl = ButtonGroupCommand::managedButtonGroups(fw);
+    // Groups: Any groups to add to except the current?
+    const int groupCount = bl.size();
+    const bool hasAddGroups = groupCount > 1 || (groupCount == 1 && !bl.contains(currentGroup));
+    if (hasAddGroups) {
+        if (!m_assignGroupSubMenu->isEmpty())
+            m_assignGroupSubMenu->addSeparator();
+        // Create a new action group
+        m_assignActionGroup = new QActionGroup(this);
+        connect(m_assignActionGroup, SIGNAL(triggered(QAction*)), this, SLOT(addToGroup(QAction*)));
+
+        const ButtonGroupList::const_iterator cend = bl.constEnd();
+        for (ButtonGroupList::const_iterator it = bl.constBegin(); it != cend; ++it) {
+            QButtonGroup *bg = *it;
+            if (*it != currentGroup) {
+                QAction *a = new QAction(bg->objectName(), m_assignGroupSubMenu);
+                a->setData(QVariant::fromValue(bg));
+                m_assignActionGroup->addAction(a);
+                m_assignGroupSubMenu->addAction(a);
+            }
+        }
+    }
+    // Can remove: A homogenous selection of another group that does not completely break it.
+    const bool canRemoveFromGroup = st == GroupedButtonSelection;
+    m_removeFromGroupAction->setEnabled(canRemoveFromGroup);
+    if (canRemoveFromGroup) {
+        if (!m_assignGroupSubMenu->isEmpty())
+            m_assignGroupSubMenu->addSeparator();
+        m_assignGroupSubMenu->addAction(m_removeFromGroupAction);
+    }
+    return !m_assignGroupSubMenu->isEmpty();
+}
+
+QList<QAction*> ButtonTaskMenu::taskActions() const
+{
+    ButtonTaskMenu *ncThis = const_cast<ButtonTaskMenu*>(this);
+    QButtonGroup *buttonGroup = 0;
+
+    QDesignerFormWindowInterface *fw = formWindow();
+    const SelectionType st = selectionType(fw->cursor(), &buttonGroup);
+
+    m_groupMenu.initialize(fw, buttonGroup, button());
+    const bool hasAssignOptions = ncThis->refreshAssignMenu(fw, fw->cursor()->selectedWidgetCount(), st, buttonGroup);
+    m_assignToGroupSubMenuAction->setVisible(hasAssignOptions);
+    // add/remove
+    switch (st) {
+    case UngroupedButtonSelection:
+    case OtherSelection:
+        m_currentGroupSubMenuAction->setVisible(false);
+        break;
+    case GroupedButtonSelection:
+        m_currentGroupSubMenuAction->setText(tr("Button group '%1'").arg(buttonGroup->objectName()));
+        m_currentGroupSubMenuAction->setVisible(true);
+        break;
+    }
+
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+
+void ButtonTaskMenu::insertAction(int index, QAction *a)
+{
+    m_taskActions.insert(index, a);
+}
+
+/* Create a button list from the cursor selection */
+static ButtonList buttonList(const QDesignerFormWindowCursorInterface *cursor)
+{
+    ButtonList rc;
+    const int selectionCount = cursor->selectedWidgetCount();
+    for (int i = 0; i < selectionCount; i++) {
+        QAbstractButton *ab = qobject_cast<QAbstractButton *>(cursor->selectedWidget(i));
+        Q_ASSERT(ab);
+        rc += ab;
+    }
+    return rc;
+}
+
+// Create a command to remove the buttons from their group
+// If it would leave an empty or 1-member group behind, create a break command instead
+
+static QUndoCommand *createRemoveButtonsCommand(QDesignerFormWindowInterface *fw, const ButtonList &bl)
+{
+
+    QButtonGroup *bg = bl.front()->group();
+    // Complete group or 1-member group?
+    if (bl.size() >= bg->buttons().size() - 1) {
+        BreakButtonGroupCommand *breakCmd = new BreakButtonGroupCommand(fw);
+        if (!breakCmd->init(bg)) {
+            qWarning("** WARNING Failed to initialize BreakButtonGroupCommand!");
+            delete breakCmd;
+            return 0;
+        }
+        return breakCmd;
+    }
+    // Just remove the buttons
+
+    RemoveButtonsFromGroupCommand *removeCmd  = new RemoveButtonsFromGroupCommand(fw);
+    if (!removeCmd->init(bl)) {
+        qWarning("** WARNING Failed to initialize RemoveButtonsFromGroupCommand!");
+        delete removeCmd;
+        return 0;
+    }
+    return removeCmd;
+}
+
+void ButtonTaskMenu::createGroup()
+{
+    QDesignerFormWindowInterface *fw = formWindow();
+    const ButtonList bl = buttonList(fw->cursor());
+    // Do we need to remove the buttons from an existing group?
+    QUndoCommand *removeCmd = 0;
+    if (bl.front()->group()) {
+        removeCmd = createRemoveButtonsCommand(fw, bl);
+        if (!removeCmd)
+            return;
+    }
+    // Add cmd
+    CreateButtonGroupCommand *addCmd = new CreateButtonGroupCommand(fw);
+    if (!addCmd->init(bl)) {
+        qWarning("** WARNING Failed to initialize CreateButtonGroupCommand!");
+        delete addCmd;
+        return;
+    }
+    // Need a macro [even if we only have the add command] since the command might trigger additional commands
+    QUndoStack *history = fw->commandHistory();
+    history->beginMacro(addCmd->text());
+    if (removeCmd)
+        history->push(removeCmd);
+    history->push(addCmd);
+    history->endMacro();
+}
+
+QAbstractButton *ButtonTaskMenu::button() const
+{
+     return qobject_cast<QAbstractButton *>(widget());
+}
+
+// Figure out if we have a homogenous selections (buttons of the same group or no group)
+ButtonTaskMenu::SelectionType ButtonTaskMenu::selectionType(const QDesignerFormWindowCursorInterface *cursor, QButtonGroup **ptrToGroup) const
+{
+    const int selectionCount = cursor->selectedWidgetCount();
+    if (!selectionCount)
+        return OtherSelection;
+
+    QButtonGroup *commonGroup = 0;
+    for (int i = 0; i < selectionCount; i++) {
+        if (const QAbstractButton *ab = qobject_cast<const QAbstractButton *>(cursor->selectedWidget(i))) {
+            QButtonGroup *buttonGroup = ab->group();
+            if (i) {
+                if (buttonGroup != commonGroup)
+                    return OtherSelection;
+            } else {
+                commonGroup = buttonGroup;
+            }
+        } else {
+            return OtherSelection;
+        }
+    }
+
+    if (ptrToGroup)
+        *ptrToGroup = commonGroup;
+
+    return commonGroup ? GroupedButtonSelection : UngroupedButtonSelection;
+}
+
+void ButtonTaskMenu::addToGroup(QAction *a)
+{
+    QButtonGroup *bg = qvariant_cast<QButtonGroup *>(a->data());
+    Q_ASSERT(bg);
+
+    QDesignerFormWindowInterface *fw = formWindow();
+    const ButtonList bl = buttonList(fw->cursor());
+    // Do we need to remove the buttons from an existing group?
+    QUndoCommand *removeCmd = 0;
+    if (bl.front()->group()) {
+        removeCmd = createRemoveButtonsCommand(fw, bl);
+        if (!removeCmd)
+            return;
+    }
+    AddButtonsToGroupCommand *addCmd = new AddButtonsToGroupCommand(fw);
+    addCmd->init(bl, bg);
+
+    QUndoStack *history = fw->commandHistory();
+    if (removeCmd) {
+        history->beginMacro(addCmd->text());
+        history->push(removeCmd);
+        history->push(addCmd);
+        history->endMacro();
+    } else {
+        history->push(addCmd);
+    }
+}
+
+void ButtonTaskMenu::removeFromGroup()
+{
+    QDesignerFormWindowInterface *fw = formWindow();
+    if (QUndoCommand *cmd = createRemoveButtonsCommand(fw, buttonList(fw->cursor())))
+        fw->commandHistory()->push(cmd);
+}
+
+// -------------- CommandLinkButtonTaskMenu
+
+CommandLinkButtonTaskMenu::CommandLinkButtonTaskMenu(QCommandLinkButton *button, QObject *parent) :
+    ButtonTaskMenu(button, parent)
+{
+    TaskMenuInlineEditor *descriptonEditor = new LinkDescriptionTaskMenuInlineEditor(button, this);
+    QAction *descriptionAction = new QAction(tr("Change description..."), this);
+    connect(descriptionAction, SIGNAL(triggered()), descriptonEditor, SLOT(editText()));
+    insertAction(1, descriptionAction);
+}
+
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/button_taskmenu.h b/src/designer/src/components/taskmenu/button_taskmenu.h
new file mode 100644
index 000000000..e7350ca87
--- /dev/null
+++ b/src/designer/src/components/taskmenu/button_taskmenu.h
@@ -0,0 +1,170 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef BUTTON_TASKMENU_H
+#define BUTTON_TASKMENU_H
+
+#include <QtGui/QAbstractButton>
+#include <QtGui/QCommandLinkButton>
+#include <QtGui/QButtonGroup>
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QMenu;
+class QActionGroup;
+class QDesignerFormWindowCursorInterface;
+
+namespace qdesigner_internal {
+
+// ButtonGroupMenu: Mixin menu for the 'select members'/'break group' options of
+// the task menu of buttons and button group
+class ButtonGroupMenu : public QObject
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(ButtonGroupMenu)
+public:
+    ButtonGroupMenu(QObject *parent = 0);
+
+    void initialize(QDesignerFormWindowInterface *formWindow,
+                    QButtonGroup *buttonGroup = 0,
+                    /* Current button for selection in ButtonMode */
+                    QAbstractButton *currentButton = 0);
+
+    QAction *selectGroupAction() const { return m_selectGroupAction; }
+    QAction *breakGroupAction() const  { return m_breakGroupAction; }
+
+private slots:
+    void selectGroup();
+    void breakGroup();
+
+private:
+    QAction *m_selectGroupAction;
+    QAction *m_breakGroupAction;
+
+    QDesignerFormWindowInterface *m_formWindow;
+    QButtonGroup *m_buttonGroup;
+    QAbstractButton *m_currentButton;
+};
+
+// Task menu extension of a QButtonGroup
+class ButtonGroupTaskMenu : public QObject, public QDesignerTaskMenuExtension
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(ButtonGroupTaskMenu)
+    Q_INTERFACES(QDesignerTaskMenuExtension)
+public:
+    explicit ButtonGroupTaskMenu(QButtonGroup *buttonGroup, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private:
+    QButtonGroup *m_buttonGroup;
+    QList<QAction*> m_taskActions;
+    mutable ButtonGroupMenu m_menu;
+};
+
+// Task menu extension of a QAbstractButton
+class ButtonTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(ButtonTaskMenu)
+public:
+    explicit ButtonTaskMenu(QAbstractButton *button, QObject *parent = 0);
+    virtual ~ButtonTaskMenu();
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+    QAbstractButton *button() const;
+
+protected:
+    void insertAction(int index, QAction *a);
+
+private slots:
+    void createGroup();
+    void addToGroup(QAction *a);
+    void removeFromGroup();
+
+private:
+    enum SelectionType {
+        OtherSelection,
+        UngroupedButtonSelection,
+        GroupedButtonSelection
+    };
+
+    SelectionType selectionType(const QDesignerFormWindowCursorInterface *cursor, QButtonGroup ** ptrToGroup = 0) const;
+    bool refreshAssignMenu(const QDesignerFormWindowInterface *fw, int buttonCount, SelectionType st, QButtonGroup *currentGroup);
+    QMenu *createGroupSelectionMenu(const QDesignerFormWindowInterface *fw);
+
+    QList<QAction*> m_taskActions;
+    mutable ButtonGroupMenu m_groupMenu;
+    QMenu *m_assignGroupSubMenu;
+    QActionGroup *m_assignActionGroup;
+    QAction *m_assignToGroupSubMenuAction;
+    QMenu *m_currentGroupSubMenu;
+    QAction *m_currentGroupSubMenuAction;
+
+    QAction *m_createGroupAction;
+    QAction *m_preferredEditAction;
+    QAction *m_removeFromGroupAction;
+};
+
+// Task menu extension of a QCommandLinkButton
+class CommandLinkButtonTaskMenu: public ButtonTaskMenu
+{
+    Q_OBJECT
+    Q_DISABLE_COPY(CommandLinkButtonTaskMenu)
+public:
+    explicit CommandLinkButtonTaskMenu(QCommandLinkButton *button, QObject *parent = 0);
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QButtonGroup, ButtonGroupTaskMenu> ButtonGroupTaskMenuFactory;
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QCommandLinkButton, CommandLinkButtonTaskMenu>  CommandLinkButtonTaskMenuFactory;
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QAbstractButton, ButtonTaskMenu>  ButtonTaskMenuFactory;
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // BUTTON_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/combobox_taskmenu.cpp b/src/designer/src/components/taskmenu/combobox_taskmenu.cpp
new file mode 100644
index 000000000..2b9b1fe19
--- /dev/null
+++ b/src/designer/src/components/taskmenu/combobox_taskmenu.cpp
@@ -0,0 +1,133 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "combobox_taskmenu.h"
+#include "listwidgeteditor.h"
+#include "qdesigner_utils_p.h"
+#include <qdesigner_command_p.h>
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QAction>
+#include <QtGui/QStyle>
+#include <QtGui/QLineEdit>
+#include <QtGui/QFontComboBox>
+#include <QtGui/QStyleOption>
+
+#include <QtCore/QEvent>
+#include <QtCore/QVariant>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace qdesigner_internal;
+
+ComboBoxTaskMenu::ComboBoxTaskMenu(QComboBox *button, QObject *parent)
+    : QDesignerTaskMenu(button, parent),
+      m_comboBox(button)
+{
+    m_editItemsAction = new QAction(this);
+    m_editItemsAction->setText(tr("Edit Items..."));
+    connect(m_editItemsAction, SIGNAL(triggered()), this, SLOT(editItems()));
+    m_taskActions.append(m_editItemsAction);
+
+    QAction *sep = new QAction(this);
+    sep->setSeparator(true);
+    m_taskActions.append(sep);
+}
+
+ComboBoxTaskMenu::~ComboBoxTaskMenu()
+{
+}
+
+QAction *ComboBoxTaskMenu::preferredEditAction() const
+{
+    return m_editItemsAction;
+}
+
+QList<QAction*> ComboBoxTaskMenu::taskActions() const
+{
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+void ComboBoxTaskMenu::editItems()
+{
+    m_formWindow = QDesignerFormWindowInterface::findFormWindow(m_comboBox);
+    if (m_formWindow.isNull())
+        return;
+
+    Q_ASSERT(m_comboBox != 0);
+
+    ListWidgetEditor dlg(m_formWindow, m_comboBox->window());
+    ListContents oldItems = dlg.fillContentsFromComboBox(m_comboBox);
+    if (dlg.exec() == QDialog::Accepted) {
+        ListContents items = dlg.contents();
+        if (items != oldItems) {
+            ChangeListContentsCommand *cmd = new ChangeListContentsCommand(m_formWindow);
+            cmd->init(m_comboBox, oldItems, items);
+            cmd->setText(tr("Change Combobox Contents"));
+            m_formWindow->commandHistory()->push(cmd);
+        }
+    }
+}
+
+ComboBoxTaskMenuFactory::ComboBoxTaskMenuFactory(const QString &iid, QExtensionManager *extensionManager) :
+    ExtensionFactory<QDesignerTaskMenuExtension, QComboBox, ComboBoxTaskMenu>(iid, extensionManager)
+{
+}
+
+QComboBox *ComboBoxTaskMenuFactory::checkObject(QObject *qObject) const
+{
+    QComboBox *combo = qobject_cast<QComboBox*>(qObject);
+    if (!combo)
+        return 0;
+    if (qobject_cast<QFontComboBox*>(combo))
+        return 0;
+    return combo;
+}
+
+void ComboBoxTaskMenu::updateSelection()
+{
+    if (m_editor)
+        m_editor->deleteLater();
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/combobox_taskmenu.h b/src/designer/src/components/taskmenu/combobox_taskmenu.h
new file mode 100644
index 000000000..c1eee4837
--- /dev/null
+++ b/src/designer/src/components/taskmenu/combobox_taskmenu.h
@@ -0,0 +1,94 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef COMBOBOX_TASKMENU_H
+#define COMBOBOX_TASKMENU_H
+
+#include <QtGui/QComboBox>
+#include <QtCore/QPointer>
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QLineEdit;
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class ComboBoxTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit ComboBoxTaskMenu(QComboBox *button,
+                              QObject *parent = 0);
+    virtual ~ComboBoxTaskMenu();
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void editItems();
+    void updateSelection();
+
+private:
+    QComboBox *m_comboBox;
+    QPointer<QDesignerFormWindowInterface> m_formWindow;
+    QPointer<QLineEdit> m_editor;
+    mutable QList<QAction*> m_taskActions;
+    QAction *m_editItemsAction;
+};
+
+class ComboBoxTaskMenuFactory : public ExtensionFactory<QDesignerTaskMenuExtension, QComboBox, ComboBoxTaskMenu>
+{
+public:
+    explicit ComboBoxTaskMenuFactory(const QString &iid, QExtensionManager *extensionManager);
+
+private:
+    virtual QComboBox *checkObject(QObject *qObject) const;
+};
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // COMBOBOX_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/containerwidget_taskmenu.cpp b/src/designer/src/components/taskmenu/containerwidget_taskmenu.cpp
new file mode 100644
index 000000000..244ea00ff
--- /dev/null
+++ b/src/designer/src/components/taskmenu/containerwidget_taskmenu.cpp
@@ -0,0 +1,348 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "containerwidget_taskmenu.h"
+
+#include <QtDesigner/QDesignerFormEditorInterface>
+#include <QtDesigner/QDesignerFormWindowInterface>
+#include <QtDesigner/QExtensionManager>
+#include <QtDesigner/QDesignerContainerExtension>
+
+#include <qdesigner_command_p.h>
+#include <qdesigner_dockwidget_p.h>
+#include <promotiontaskmenu_p.h>
+#include <widgetdatabase_p.h>
+
+#include <QtGui/QAction>
+#include <QtGui/QMainWindow>
+#include <QtGui/QToolBox>
+#include <QtGui/QStackedWidget>
+#include <QtGui/QTabWidget>
+#include <QtGui/QScrollArea>
+#include <QtGui/QMdiArea>
+#include <QtGui/QWorkspace>
+#include <QtGui/QWizard>
+#include <QtGui/QMenu>
+
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+ContainerWidgetTaskMenu::ContainerWidgetTaskMenu(QWidget *widget, ContainerType type, QObject *parent) :
+    QDesignerTaskMenu(widget, parent),
+    m_type(type),
+    m_containerWidget(widget),
+    m_core(formWindow()->core()),
+    m_pagePromotionTaskMenu(new PromotionTaskMenu(0, PromotionTaskMenu::ModeSingleWidget, this)),
+    m_pageMenuAction(new QAction(this)),
+    m_pageMenu(new QMenu),
+    m_actionDeletePage(new QAction(tr("Delete"), this))
+{
+    Q_ASSERT(m_core);
+    m_taskActions.append(createSeparator());
+
+    connect(m_actionDeletePage, SIGNAL(triggered()), this, SLOT(removeCurrentPage()));
+
+    QAction *actionInsertPageAfter = new QAction(this);
+    connect(actionInsertPageAfter, SIGNAL(triggered()), this, SLOT(addPageAfter()));
+    // Empty Per-Page submenu, deletion and promotion. Updated on demand due to promotion state
+    switch (m_type) {
+    case WizardContainer:
+    case PageContainer:
+        m_taskActions.append(createSeparator()); // for the browse actions
+        break;
+    case MdiContainer:
+        break;
+    }
+    // submenu
+    m_pageMenuAction->setMenu(m_pageMenu);
+    m_taskActions.append(m_pageMenuAction);
+    // Insertion
+    switch (m_type) {
+    case WizardContainer:
+    case PageContainer: { // Before and after in a submenu
+        QAction *insertMenuAction = new QAction(tr("Insert"), this);
+        QMenu *insertMenu = new QMenu;
+        // before
+        QAction *actionInsertPage = new QAction(tr("Insert Page Before Current Page"), this);
+        connect(actionInsertPage, SIGNAL(triggered()), this, SLOT(addPage()));
+        insertMenu->addAction(actionInsertPage);
+        // after
+        actionInsertPageAfter->setText(tr("Insert Page After Current Page"));
+        insertMenu->addAction(actionInsertPageAfter);
+
+        insertMenuAction->setMenu(insertMenu);
+        m_taskActions.append(insertMenuAction);
+    }
+        break;
+    case MdiContainer: // No concept of order
+        actionInsertPageAfter->setText(tr("Add Subwindow"));
+        m_taskActions.append(actionInsertPageAfter);
+        break;
+    }
+}
+
+ContainerWidgetTaskMenu::~ContainerWidgetTaskMenu()
+{
+}
+
+QAction *ContainerWidgetTaskMenu::preferredEditAction() const
+{
+    return 0;
+}
+
+bool ContainerWidgetTaskMenu::canDeletePage() const
+{
+    switch (pageCount()) {
+    case 0:
+        return false;
+    case 1:
+        return m_type != PageContainer; // Do not delete last page of page-type container
+    default:
+        break;
+    }
+    return true;
+}
+
+int ContainerWidgetTaskMenu::pageCount() const
+{
+    if (const QDesignerContainerExtension *ce = containerExtension())
+        return ce->count();
+    return 0;
+}
+
+QString ContainerWidgetTaskMenu::pageMenuText(ContainerType ct, int index, int count)
+{
+    if (ct == MdiContainer)
+        return tr("Subwindow"); // No concept of order, same text everywhere
+    if (index < 0)
+        return tr("Page");
+    return tr("Page %1 of %2").arg(index + 1).arg(count);
+}
+
+QList<QAction*> ContainerWidgetTaskMenu::taskActions() const
+{
+    QList<QAction*> actions = QDesignerTaskMenu::taskActions();
+    actions += m_taskActions;
+    // Update the page submenu, deletion and promotion. Updated on demand due to promotion state.
+    m_pageMenu->clear();
+    m_pageMenu->addAction(m_actionDeletePage);
+    m_actionDeletePage->setEnabled(canDeletePage());
+    const QDesignerContainerExtension *ce = containerExtension();
+    const int index = ce->currentIndex();
+    m_pageMenuAction->setText(pageMenuText(m_type, index, ce->count()));
+    if (index != -1) { // Has a page
+        m_pageMenuAction->setEnabled(true);
+        m_pagePromotionTaskMenu->setWidget(ce->widget(index));
+        m_pagePromotionTaskMenu->addActions(PromotionTaskMenu::LeadingSeparator|PromotionTaskMenu::SuppressGlobalEdit, m_pageMenu);
+    } else { // No page
+        m_pageMenuAction->setEnabled(false);
+    }
+
+    return actions;
+}
+
+QDesignerFormWindowInterface *ContainerWidgetTaskMenu::formWindow() const
+{
+    return QDesignerFormWindowInterface::findFormWindow(m_containerWidget);
+}
+
+QDesignerContainerExtension *ContainerWidgetTaskMenu::containerExtension() const
+{
+    QExtensionManager *mgr = m_core->extensionManager();
+    return qt_extension<QDesignerContainerExtension*>(mgr, m_containerWidget);
+}
+
+void ContainerWidgetTaskMenu::removeCurrentPage()
+{
+    if (QDesignerContainerExtension *c = containerExtension()) {
+        if (c->currentIndex() == -1)
+            return;
+
+        QDesignerFormWindowInterface *fw = formWindow();
+        DeleteContainerWidgetPageCommand *cmd = new DeleteContainerWidgetPageCommand(fw);
+        cmd->init(m_containerWidget, m_type);
+        fw->commandHistory()->push(cmd);
+    }
+}
+
+void ContainerWidgetTaskMenu::addPage()
+{
+    if (containerExtension()) {
+        QDesignerFormWindowInterface *fw = formWindow();
+        AddContainerWidgetPageCommand *cmd = new AddContainerWidgetPageCommand(fw);
+        cmd->init(m_containerWidget, m_type, AddContainerWidgetPageCommand::InsertBefore);
+        fw->commandHistory()->push(cmd);
+    }
+}
+
+void ContainerWidgetTaskMenu::addPageAfter()
+{
+    if (containerExtension()) {
+        QDesignerFormWindowInterface *fw = formWindow();
+        AddContainerWidgetPageCommand *cmd = new AddContainerWidgetPageCommand(fw);
+        cmd->init(m_containerWidget, m_type, AddContainerWidgetPageCommand::InsertAfter);
+        fw->commandHistory()->push(cmd);
+    }
+}
+
+// -------------- WizardContainerWidgetTaskMenu
+WizardContainerWidgetTaskMenu::WizardContainerWidgetTaskMenu(QWizard *w, QObject *parent) :
+    ContainerWidgetTaskMenu(w, WizardContainer, parent),
+    m_nextAction(new QAction(tr("Next"), this)),
+    m_previousAction(new QAction(tr("Back"), this))
+{
+    connect(m_nextAction, SIGNAL(triggered()), w, SLOT(next()));
+    connect(m_previousAction, SIGNAL(triggered()), w, SLOT(back()));
+    QList<QAction*> &l = containerActions();
+    l.push_front(createSeparator());
+    l.push_front(m_nextAction);
+    l.push_front(m_previousAction);
+    l.push_front(createSeparator());
+}
+
+QList<QAction*> WizardContainerWidgetTaskMenu::taskActions() const
+{
+    // Enable
+    const QDesignerContainerExtension *ce = containerExtension();
+    const int index = ce->currentIndex();
+    m_previousAction->setEnabled(index > 0);
+    m_nextAction->setEnabled(index >= 0 && index < (ce->count() - 1));
+    return ContainerWidgetTaskMenu::taskActions();
+}
+
+// -------------- MdiContainerWidgetTaskMenu
+
+MdiContainerWidgetTaskMenu::MdiContainerWidgetTaskMenu(QMdiArea *m, QObject *parent) :
+    ContainerWidgetTaskMenu(m, MdiContainer, parent)
+{
+    initializeActions();
+    connect(m_nextAction, SIGNAL(triggered()), m, SLOT(activateNextSubWindow()));
+    connect(m_previousAction, SIGNAL(triggered()), m , SLOT(activatePreviousSubWindow()));
+    connect(m_tileAction, SIGNAL(triggered()), m, SLOT(tileSubWindows()));
+    connect(m_cascadeAction, SIGNAL(triggered()), m, SLOT(cascadeSubWindows()));
+}
+
+MdiContainerWidgetTaskMenu::MdiContainerWidgetTaskMenu(QWorkspace *m, QObject *parent) :
+    ContainerWidgetTaskMenu(m, MdiContainer, parent)
+{
+    initializeActions();
+    connect(m_nextAction, SIGNAL(triggered()), m, SLOT(activateNextWindow()));
+    connect(m_previousAction, SIGNAL(triggered()), m, SLOT(activatePreviousWindow()));
+    connect(m_tileAction, SIGNAL(triggered()),m , SLOT(tile()));
+    connect(m_cascadeAction, SIGNAL(triggered()), m, SLOT(cascade()));
+}
+
+void MdiContainerWidgetTaskMenu::initializeActions()
+{
+    m_nextAction =new QAction(tr("Next Subwindow"), this);
+    m_previousAction = new QAction(tr("Previous Subwindow"), this);
+    m_tileAction = new QAction(tr("Tile"), this);
+    m_cascadeAction = new QAction(tr("Cascade"), this);
+
+    QList<QAction*> &l = containerActions();
+    l.push_front(createSeparator());
+    l.push_front(m_tileAction);
+    l.push_front(m_cascadeAction);
+    l.push_front(m_previousAction);
+    l.push_front(m_nextAction);
+    l.push_front(createSeparator());
+}
+
+QList<QAction*> MdiContainerWidgetTaskMenu::taskActions() const
+{
+    const QList<QAction*> rc = ContainerWidgetTaskMenu::taskActions();
+    // Enable
+    const int count = pageCount();
+    m_nextAction->setEnabled(count > 1);
+    m_previousAction->setEnabled(count > 1);
+    m_tileAction->setEnabled(count);
+    m_cascadeAction->setEnabled(count);
+    return rc;
+}
+
+// --------------  ContainerWidgetTaskMenuFactory
+
+ContainerWidgetTaskMenuFactory::ContainerWidgetTaskMenuFactory(QDesignerFormEditorInterface *core, QExtensionManager *extensionManager) :
+    QExtensionFactory(extensionManager),
+    m_core(core)
+{
+}
+
+QObject *ContainerWidgetTaskMenuFactory::createExtension(QObject *object, const QString &iid, QObject *parent) const
+{
+    if (iid != QLatin1String("QDesignerInternalTaskMenuExtension") || !object->isWidgetType())
+        return 0;
+
+    QWidget *widget = qobject_cast<QWidget*>(object);
+
+    if (qobject_cast<QStackedWidget*>(widget)
+            || qobject_cast<QToolBox*>(widget)
+            || qobject_cast<QTabWidget*>(widget)
+            || qobject_cast<QDesignerDockWidget*>(widget)
+            || qobject_cast<QScrollArea*>(widget)
+            || qobject_cast<QMainWindow*>(widget)) {
+        // Are we using Designer's own container extensions and task menus or did
+        // someone provide an extra one with an addpage method, for example for a QScrollArea?
+        if (const WidgetDataBase *wb = qobject_cast<const WidgetDataBase *>(m_core->widgetDataBase())) {
+            const int idx = wb->indexOfObject(widget);
+            const WidgetDataBaseItem *item = static_cast<const WidgetDataBaseItem *>(wb->item(idx));
+            if (item->addPageMethod().isEmpty())
+                return 0;
+        }
+    }
+
+    if (qt_extension<QDesignerContainerExtension*>(extensionManager(), object) == 0)
+        return 0;
+
+    if (QMdiArea* ma = qobject_cast<QMdiArea*>(widget))
+        return new MdiContainerWidgetTaskMenu(ma, parent);
+    if (QWorkspace *ws = qobject_cast<QWorkspace*>(widget))
+        return new MdiContainerWidgetTaskMenu(ws, parent);
+    if (QWizard *wz = qobject_cast<QWizard *>(widget))
+        return new WizardContainerWidgetTaskMenu(wz, parent);
+    return new ContainerWidgetTaskMenu(widget, PageContainer, parent);
+}
+
+}
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/containerwidget_taskmenu.h b/src/designer/src/components/taskmenu/containerwidget_taskmenu.h
new file mode 100644
index 000000000..6c5f1d481
--- /dev/null
+++ b/src/designer/src/components/taskmenu/containerwidget_taskmenu.h
@@ -0,0 +1,157 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef CONTAINERWIDGER_TASKMENU_H
+#define CONTAINERWIDGER_TASKMENU_H
+
+#include <qdesigner_taskmenu_p.h>
+#include <shared_enums_p.h>
+
+#include <extensionfactory_p.h>
+
+#include <QtCore/QPointer>
+
+QT_BEGIN_NAMESPACE
+
+class QDesignerFormWindowInterface;
+class QDesignerFormEditorInterface;
+class QDesignerContainerExtension;
+class QAction;
+class QMdiArea;
+class QWorkspace;
+class QMenu;
+class QWizard;
+
+namespace qdesigner_internal {
+
+class PromotionTaskMenu;
+
+// ContainerWidgetTaskMenu: Task menu for containers with extension
+
+class ContainerWidgetTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit ContainerWidgetTaskMenu(QWidget *widget, ContainerType type, QObject *parent = 0);
+    virtual ~ContainerWidgetTaskMenu();
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void removeCurrentPage();
+    void addPage();
+    void addPageAfter();
+
+protected:
+    QDesignerContainerExtension *containerExtension() const;
+    QList<QAction*> &containerActions() { return m_taskActions; }
+    int pageCount() const;
+
+private:
+    QDesignerFormWindowInterface *formWindow() const;
+
+private:
+    static QString pageMenuText(ContainerType ct, int index, int count);
+    bool canDeletePage() const;
+
+    const ContainerType m_type;
+    QWidget *m_containerWidget;
+    QDesignerFormEditorInterface *m_core;
+    PromotionTaskMenu *m_pagePromotionTaskMenu;
+    QAction *m_pageMenuAction;
+    QMenu *m_pageMenu;
+    QList<QAction*> m_taskActions;
+    QAction *m_actionDeletePage;
+};
+
+// WizardContainerWidgetTaskMenu: Provide next/back since QWizard
+// has modes in which the "Back" button is not visible.
+
+class WizardContainerWidgetTaskMenu : public ContainerWidgetTaskMenu {
+    Q_OBJECT
+public:
+    explicit WizardContainerWidgetTaskMenu(QWizard *w, QObject *parent = 0);
+
+    virtual QList<QAction*> taskActions() const;
+
+private:
+    QAction *m_nextAction;
+    QAction *m_previousAction;
+};
+
+
+// MdiContainerWidgetTaskMenu: Provide tile/cascade for MDI containers in addition
+
+class MdiContainerWidgetTaskMenu : public ContainerWidgetTaskMenu {
+    Q_OBJECT
+public:
+    explicit MdiContainerWidgetTaskMenu(QMdiArea *m, QObject *parent = 0);
+    explicit MdiContainerWidgetTaskMenu(QWorkspace *m, QObject *parent = 0);
+
+    virtual QList<QAction*> taskActions() const;
+private:
+    void initializeActions();
+
+    QAction *m_nextAction;
+    QAction *m_previousAction;
+    QAction *m_tileAction;
+    QAction *m_cascadeAction;
+};
+
+class ContainerWidgetTaskMenuFactory: public QExtensionFactory
+{
+    Q_OBJECT
+public:
+    explicit ContainerWidgetTaskMenuFactory(QDesignerFormEditorInterface *core, QExtensionManager *extensionManager = 0);
+
+protected:
+    virtual QObject *createExtension(QObject *object, const QString &iid, QObject *parent) const;
+
+private:
+    QDesignerFormEditorInterface *m_core;
+};
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // CONTAINERWIDGER_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/groupbox_taskmenu.cpp b/src/designer/src/components/taskmenu/groupbox_taskmenu.cpp
new file mode 100644
index 000000000..1fae0f8ba
--- /dev/null
+++ b/src/designer/src/components/taskmenu/groupbox_taskmenu.cpp
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "groupbox_taskmenu.h"
+#include "inplace_editor.h"
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QAction>
+#include <QtGui/QStyle>
+#include <QtGui/QStyleOption>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+// -------- GroupBoxTaskMenuInlineEditor
+class GroupBoxTaskMenuInlineEditor : public  TaskMenuInlineEditor
+{
+public:
+    GroupBoxTaskMenuInlineEditor(QGroupBox *button, QObject *parent);
+
+protected:
+    virtual QRect editRectangle() const;
+};
+
+GroupBoxTaskMenuInlineEditor::GroupBoxTaskMenuInlineEditor(QGroupBox *w, QObject *parent) :
+      TaskMenuInlineEditor(w, ValidationSingleLine, QLatin1String("title"), parent)
+{
+}
+
+QRect GroupBoxTaskMenuInlineEditor::editRectangle() const
+{
+    QWidget *w = widget();
+    QStyleOption opt; // ## QStyleOptionGroupBox
+    opt.init(w);
+    return QRect(QPoint(), QSize(w->width(),20));
+}
+
+// --------------- GroupBoxTaskMenu
+
+GroupBoxTaskMenu::GroupBoxTaskMenu(QGroupBox *groupbox, QObject *parent)
+    : QDesignerTaskMenu(groupbox, parent),
+      m_editTitleAction(new QAction(tr("Change title..."), this))
+
+{
+    TaskMenuInlineEditor *editor = new GroupBoxTaskMenuInlineEditor(groupbox, this);
+    connect(m_editTitleAction, SIGNAL(triggered()), editor, SLOT(editText()));
+    m_taskActions.append(m_editTitleAction);
+
+    QAction *sep = new QAction(this);
+    sep->setSeparator(true);
+    m_taskActions.append(sep);
+}
+
+QList<QAction*> GroupBoxTaskMenu::taskActions() const
+{
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+QAction *GroupBoxTaskMenu::preferredEditAction() const
+{
+    return m_editTitleAction;
+}
+
+}
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/groupbox_taskmenu.h b/src/designer/src/components/taskmenu/groupbox_taskmenu.h
new file mode 100644
index 000000000..d30d8b1b6
--- /dev/null
+++ b/src/designer/src/components/taskmenu/groupbox_taskmenu.h
@@ -0,0 +1,77 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef GROUPBOX_TASKMENU_H
+#define GROUPBOX_TASKMENU_H
+
+#include <QtGui/QGroupBox>
+#include <QtCore/QPointer>
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+class InPlaceEditor;
+
+class GroupBoxTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit GroupBoxTaskMenu(QGroupBox *groupbox, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private:
+    QAction *m_editTitleAction;
+    QList<QAction*> m_taskActions;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QGroupBox, GroupBoxTaskMenu>  GroupBoxTaskMenuFactory;
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // GROUPBOX_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/inplace_editor.cpp b/src/designer/src/components/taskmenu/inplace_editor.cpp
new file mode 100644
index 000000000..fd74b25f4
--- /dev/null
+++ b/src/designer/src/components/taskmenu/inplace_editor.cpp
@@ -0,0 +1,136 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "abstractformwindow.h"
+#include "inplace_editor.h"
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+#include <QtDesigner/QDesignerFormWindowCursorInterface>
+#include <QtDesigner/QDesignerPropertySheetExtension>
+#include <QtDesigner/QDesignerFormEditorInterface>
+#include <QtDesigner/QDesignerLanguageExtension>
+#include <QtDesigner/QExtensionManager>
+
+#include <QtCore/QVariant>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+// ----------------- InPlaceEditor
+
+InPlaceEditor::InPlaceEditor(QWidget *widget,
+                             TextPropertyValidationMode validationMode,
+                             QDesignerFormWindowInterface *fw,
+                             const QString& text,
+                             const QRect& r) :
+    TextPropertyEditor(widget, EmbeddingInPlace, validationMode),
+    m_InPlaceWidgetHelper(this, widget, fw)
+{
+    setAlignment(m_InPlaceWidgetHelper.alignment());
+    setObjectName(QLatin1String("__qt__passive_m_editor"));
+
+    setText(text);
+    selectAll();
+
+    setGeometry(QRect(widget->mapTo(widget->window(), r.topLeft()), r.size()));
+    setFocus();
+    show();
+
+    connect(this, SIGNAL(editingFinished()),this, SLOT(close()));
+}
+
+
+// -------------- TaskMenuInlineEditor
+
+TaskMenuInlineEditor::TaskMenuInlineEditor(QWidget *w, TextPropertyValidationMode vm,
+                                           const QString &property, QObject *parent) :
+    QObject(parent),
+    m_vm(vm),
+    m_property(property),
+    m_widget(w),
+    m_managed(true)
+{
+}
+
+void TaskMenuInlineEditor::editText()
+{
+    m_formWindow = QDesignerFormWindowInterface::findFormWindow(m_widget);
+    if (m_formWindow.isNull())
+        return;
+    m_managed = m_formWindow->isManaged(m_widget);
+    // Close as soon as a different widget is selected
+    connect(m_formWindow, SIGNAL(selectionChanged()), this, SLOT(updateSelection()));
+
+    // get old value
+    QDesignerFormEditorInterface *core = m_formWindow->core();
+    const QDesignerPropertySheetExtension *sheet = qt_extension<QDesignerPropertySheetExtension*>(core->extensionManager(), m_widget);
+    const int index = sheet->indexOf(m_property);
+    if (index == -1)
+        return;
+    m_value = qvariant_cast<PropertySheetStringValue>(sheet->property(index));
+    const QString oldValue = m_value.value();
+
+    m_editor = new InPlaceEditor(m_widget, m_vm, m_formWindow, oldValue, editRectangle());
+    connect(m_editor, SIGNAL(textChanged(QString)), this, SLOT(updateText(QString)));
+}
+
+void TaskMenuInlineEditor::updateText(const QString &text)
+{
+    // In the [rare] event we are invoked on an unmanaged widget,
+    // do not use the cursor selection
+    m_value.setValue(text);
+    if (m_managed) {
+        m_formWindow->cursor()->setProperty(m_property, QVariant::fromValue(m_value));
+    } else {
+        m_formWindow->cursor()->setWidgetProperty(m_widget, m_property, QVariant::fromValue(m_value));
+    }
+}
+
+void TaskMenuInlineEditor::updateSelection()
+{
+    if (m_editor)
+        m_editor->deleteLater();
+}
+
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/inplace_editor.h b/src/designer/src/components/taskmenu/inplace_editor.h
new file mode 100644
index 000000000..573185cb8
--- /dev/null
+++ b/src/designer/src/components/taskmenu/inplace_editor.h
@@ -0,0 +1,110 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef INPLACE_EDITOR_H
+#define INPLACE_EDITOR_H
+
+#include <textpropertyeditor_p.h>
+#include <shared_enums_p.h>
+
+#include "inplace_widget_helper.h"
+#include <qdesigner_utils_p.h>
+
+#include <QtCore/QPointer>
+
+QT_BEGIN_NAMESPACE
+
+
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class InPlaceEditor: public TextPropertyEditor
+{
+    Q_OBJECT
+public:
+    InPlaceEditor(QWidget *widget,
+                  TextPropertyValidationMode validationMode,
+                  QDesignerFormWindowInterface *fw,
+                  const QString& text,
+                  const QRect& r);
+private:
+    InPlaceWidgetHelper m_InPlaceWidgetHelper;
+};
+
+// Base class for inline editor helpers to be embedded into a task menu.
+// Inline-edits a property on a multi-selection.
+// To use it for a particular widget/property, overwrite the method
+// returning the edit area.
+
+class TaskMenuInlineEditor : public QObject {
+    TaskMenuInlineEditor(const TaskMenuInlineEditor&);
+    TaskMenuInlineEditor &operator=(const TaskMenuInlineEditor&);
+    Q_OBJECT
+
+public slots:
+    void editText();
+
+private slots:
+    void updateText(const QString &text);
+    void updateSelection();
+
+protected:
+    TaskMenuInlineEditor(QWidget *w, TextPropertyValidationMode vm, const QString &property, QObject *parent);
+    // Overwrite to return the area for the inline editor.
+    virtual QRect editRectangle() const = 0;
+    QWidget *widget() const { return m_widget; }
+
+private:
+    const TextPropertyValidationMode m_vm;
+    const QString m_property;
+    QWidget *m_widget;
+    QPointer<QDesignerFormWindowInterface> m_formWindow;
+    QPointer<InPlaceEditor> m_editor;
+    bool m_managed;
+    qdesigner_internal::PropertySheetStringValue m_value;
+};
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // INPLACE_EDITOR_H
diff --git a/src/designer/src/components/taskmenu/inplace_widget_helper.cpp b/src/designer/src/components/taskmenu/inplace_widget_helper.cpp
new file mode 100644
index 000000000..47554b3a8
--- /dev/null
+++ b/src/designer/src/components/taskmenu/inplace_widget_helper.cpp
@@ -0,0 +1,120 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "abstractformwindow.h"
+#include "inplace_widget_helper.h"
+
+#include <QtGui/QResizeEvent>
+#include <QtGui/QPushButton>
+#include <QtGui/QToolButton>
+#include <QtGui/QShortcut>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+    InPlaceWidgetHelper::InPlaceWidgetHelper(QWidget *editorWidget, QWidget *parentWidget, QDesignerFormWindowInterface *fw)
+        : QObject(0),
+    m_editorWidget(editorWidget),
+    m_parentWidget(parentWidget),
+    m_noChildEvent(m_parentWidget->testAttribute(Qt::WA_NoChildEventsForParent))
+    {
+        m_editorWidget->setAttribute(Qt::WA_DeleteOnClose);
+        m_editorWidget->setParent(m_parentWidget->window());
+        m_parentWidget->installEventFilter(this);
+        m_editorWidget->installEventFilter(this);
+        connect(m_editorWidget, SIGNAL(destroyed()), fw->mainContainer(), SLOT(setFocus()));
+    }
+
+    InPlaceWidgetHelper::~InPlaceWidgetHelper()
+    {
+        m_parentWidget->setAttribute(Qt::WA_NoChildEventsForParent, m_noChildEvent);
+    }
+
+    Qt::Alignment InPlaceWidgetHelper::alignment() const {
+         if (m_parentWidget->metaObject()->indexOfProperty("alignment") != -1)
+             return Qt::Alignment(m_parentWidget->property("alignment").toInt());
+
+         if (qobject_cast<const QPushButton *>(m_parentWidget)
+             || qobject_cast<const QToolButton *>(m_parentWidget) /* tool needs to be more complex */)
+             return Qt::AlignHCenter;
+
+         return Qt::AlignJustify;
+     }
+
+
+    bool InPlaceWidgetHelper::eventFilter(QObject *object, QEvent *e)
+    {
+        if (object == m_parentWidget) {
+            if (e->type() == QEvent::Resize) {
+                const QResizeEvent *event = static_cast<const QResizeEvent*>(e);
+                const QPoint localPos = m_parentWidget->geometry().topLeft();
+                const QPoint globalPos = m_parentWidget->parentWidget() ? m_parentWidget->parentWidget()->mapToGlobal(localPos) : localPos;
+                const QPoint newPos = (m_editorWidget->parentWidget() ? m_editorWidget->parentWidget()->mapFromGlobal(globalPos) : globalPos)
+                    + m_posOffset;
+                const QSize newSize = event->size() + m_sizeOffset;
+                m_editorWidget->setGeometry(QRect(newPos, newSize));
+            }
+        } else if (object == m_editorWidget) {
+            if (e->type() == QEvent::ShortcutOverride) {
+                if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Escape) {
+                    e->accept();
+                    return false;
+                }
+            } else if (e->type() == QEvent::KeyPress) {
+                if (static_cast<QKeyEvent*>(e)->key() == Qt::Key_Escape) {
+                    e->accept();
+                    m_editorWidget->close();
+                    return true;
+                }
+            } else if (e->type() == QEvent::Show) {
+                const QPoint localPos = m_parentWidget->geometry().topLeft();
+                const QPoint globalPos = m_parentWidget->parentWidget() ? m_parentWidget->parentWidget()->mapToGlobal(localPos) : localPos;
+                const QPoint newPos = m_editorWidget->parentWidget() ? m_editorWidget->parentWidget()->mapFromGlobal(globalPos) : globalPos;
+                m_posOffset = m_editorWidget->geometry().topLeft() - newPos;
+                m_sizeOffset = m_editorWidget->size() - m_parentWidget->size();
+            }
+        }
+
+        return QObject::eventFilter(object, e);
+    }
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/inplace_widget_helper.h b/src/designer/src/components/taskmenu/inplace_widget_helper.h
new file mode 100644
index 000000000..663516004
--- /dev/null
+++ b/src/designer/src/components/taskmenu/inplace_widget_helper.h
@@ -0,0 +1,88 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef INPLACE_WIDGETHELPER_H
+#define INPLACE_WIDGETHELPER_H
+
+
+#include <QtCore/QObject>
+#include <QtCore/QPoint>
+#include <QtCore/QSize>
+#include <qglobal.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+    // A helper class to make an editor widget suitable for form inline
+    // editing. Derive from the editor widget class and  make InPlaceWidgetHelper  a member.
+    //
+    // Sets "destructive close" on the editor widget and
+    // wires "ESC" to it.
+    // Installs an event filter on the parent to listen for
+    // resize events and passes them on to the child.
+    // You might want to connect editingFinished() to close() of the editor widget.
+    class InPlaceWidgetHelper: public QObject
+    {
+        Q_OBJECT
+    public:
+        InPlaceWidgetHelper(QWidget *editorWidget, QWidget *parentWidget, QDesignerFormWindowInterface *fw);
+        virtual ~InPlaceWidgetHelper();
+
+        virtual bool eventFilter(QObject *object, QEvent *event);
+
+        // returns a recommended alignment for the editor widget determined from the parent.
+        Qt::Alignment alignment() const;
+    private:
+        QWidget *m_editorWidget;
+        QWidget *m_parentWidget;
+        const bool m_noChildEvent;
+        QPoint m_posOffset;
+        QSize m_sizeOffset;
+    };
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // INPLACE_WIDGETHELPER_H
diff --git a/src/designer/src/components/taskmenu/itemlisteditor.cpp b/src/designer/src/components/taskmenu/itemlisteditor.cpp
new file mode 100644
index 000000000..a04246de5
--- /dev/null
+++ b/src/designer/src/components/taskmenu/itemlisteditor.cpp
@@ -0,0 +1,478 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "itemlisteditor.h"
+#include <abstractformbuilder.h>
+#include <iconloader_p.h>
+#include <formwindowbase_p.h>
+#include <designerpropertymanager.h>
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <qttreepropertybrowser.h>
+
+#include <QtGui/QSplitter>
+#include <QtCore/QCoreApplication>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+class ItemPropertyBrowser : public QtTreePropertyBrowser
+{
+public:
+    ItemPropertyBrowser()
+    {
+        setResizeMode(Interactive);
+        //: Sample string to determinate the width for the first column of the list item property browser
+        const QString widthSampleString = QCoreApplication::translate("ItemPropertyBrowser", "XX Icon Selected off");
+        m_width = fontMetrics().width(widthSampleString);
+        setSplitterPosition(m_width);
+        m_width += fontMetrics().width(QLatin1String("/this/is/some/random/path"));
+    }
+
+    virtual QSize sizeHint() const
+    {
+        return QSize(m_width, 1);
+    }
+
+private:
+    int m_width;
+};
+
+////////////////// Item editor ///////////////
+AbstractItemEditor::AbstractItemEditor(QDesignerFormWindowInterface *form, QWidget *parent)
+    : QWidget(parent),
+      m_iconCache(qobject_cast<FormWindowBase *>(form)->iconCache()),
+      m_updatingBrowser(false)
+{
+    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+    m_propertyManager = new DesignerPropertyManager(form->core(), this);
+    m_editorFactory = new DesignerEditorFactory(form->core(), this);
+    m_editorFactory->setSpacing(0);
+    m_propertyBrowser = new ItemPropertyBrowser;
+    m_propertyBrowser->setFactoryForManager((QtVariantPropertyManager *)m_propertyManager,
+                                            m_editorFactory);
+
+    connect(m_editorFactory, SIGNAL(resetProperty(QtProperty*)),
+            SLOT(resetProperty(QtProperty*)));
+    connect(m_propertyManager, SIGNAL(valueChanged(QtProperty*,QVariant,bool)),
+            SLOT(propertyChanged(QtProperty*)));
+    connect(iconCache(), SIGNAL(reloaded()), this, SLOT(cacheReloaded()));
+}
+
+AbstractItemEditor::~AbstractItemEditor()
+{
+    m_propertyBrowser->unsetFactoryForManager(m_propertyManager);
+}
+
+static const char * const itemFlagNames[] = {
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "Selectable"),
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "Editable"),
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "DragEnabled"),
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "DropEnabled"),
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "UserCheckable"),
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "Enabled"),
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "Tristate"),
+    0
+};
+
+static const char * const checkStateNames[] = {
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "Unchecked"),
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "PartiallyChecked"),
+    QT_TRANSLATE_NOOP("AbstractItemEditor", "Checked"),
+    0
+};
+
+static QStringList c2qStringList(const char * const in[])
+{
+    QStringList out;
+    for (int i = 0; in[i]; i++)
+        out << AbstractItemEditor::tr(in[i]);
+    return out;
+}
+
+void AbstractItemEditor::setupProperties(PropertyDefinition *propList)
+{
+    for (int i = 0; propList[i].name; i++) {
+        int type = propList[i].typeFunc ? propList[i].typeFunc() : propList[i].type;
+        int role = propList[i].role;
+        QtVariantProperty *prop = m_propertyManager->addProperty(type, QLatin1String(propList[i].name));
+        Q_ASSERT(prop);
+        if (role == Qt::ToolTipPropertyRole || role == Qt::WhatsThisPropertyRole)
+            prop->setAttribute(QLatin1String("validationMode"), ValidationRichText);
+        else if (role == Qt::DisplayPropertyRole)
+            prop->setAttribute(QLatin1String("validationMode"), ValidationMultiLine);
+        else if (role == Qt::StatusTipPropertyRole)
+            prop->setAttribute(QLatin1String("validationMode"), ValidationSingleLine);
+        else if (role == ItemFlagsShadowRole)
+            prop->setAttribute(QLatin1String("flagNames"), c2qStringList(itemFlagNames));
+        else if (role == Qt::CheckStateRole)
+            prop->setAttribute(QLatin1String("enumNames"), c2qStringList(checkStateNames));
+        prop->setAttribute(QLatin1String("resettable"), true);
+        m_properties.append(prop);
+        m_rootProperties.append(prop);
+        m_propertyToRole.insert(prop, role);
+    }
+}
+
+void AbstractItemEditor::setupObject(QWidget *object)
+{
+    m_propertyManager->setObject(object);
+    QDesignerFormWindowInterface *formWindow = QDesignerFormWindowInterface::findFormWindow(object);
+    FormWindowBase *fwb = qobject_cast<FormWindowBase *>(formWindow);
+    m_editorFactory->setFormWindowBase(fwb);
+}
+
+void AbstractItemEditor::setupEditor(QWidget *object, PropertyDefinition *propList)
+{
+    setupProperties(propList);
+    setupObject(object);
+}
+
+void AbstractItemEditor::propertyChanged(QtProperty *property)
+{
+    if (m_updatingBrowser)
+        return;
+
+
+    BoolBlocker block(m_updatingBrowser);
+    QtVariantProperty *prop = m_propertyManager->variantProperty(property);
+    int role;
+    if ((role = m_propertyToRole.value(prop, -1)) == -1)
+        // Subproperty
+        return;
+
+    if ((role == ItemFlagsShadowRole && prop->value().toInt() == (int)QListWidgetItem().flags())
+        || (role == Qt::DecorationPropertyRole && !qvariant_cast<PropertySheetIconValue>(prop->value()).mask())
+        || (role == Qt::FontRole && !qvariant_cast<QFont>(prop->value()).resolve())) {
+        prop->setModified(false);
+        setItemData(role, QVariant());
+    } else {
+        prop->setModified(true);
+        setItemData(role, prop->value());
+    }
+
+    switch (role) {
+    case Qt::DecorationPropertyRole:
+        setItemData(Qt::DecorationRole, QVariant::fromValue(iconCache()->icon(qvariant_cast<PropertySheetIconValue>(prop->value()))));
+        break;
+    case Qt::DisplayPropertyRole:
+        setItemData(Qt::EditRole, QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(prop->value()).value()));
+        break;
+    case Qt::ToolTipPropertyRole:
+        setItemData(Qt::ToolTipRole, QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(prop->value()).value()));
+        break;
+    case Qt::StatusTipPropertyRole:
+        setItemData(Qt::StatusTipRole, QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(prop->value()).value()));
+        break;
+    case Qt::WhatsThisPropertyRole:
+        setItemData(Qt::WhatsThisRole, QVariant::fromValue(qvariant_cast<PropertySheetStringValue>(prop->value()).value()));
+        break;
+    default:
+        break;
+    }
+
+    prop->setValue(getItemData(role));
+}
+
+void AbstractItemEditor::resetProperty(QtProperty *property)
+{
+    if (m_propertyManager->resetFontSubProperty(property))
+        return;
+
+    if (m_propertyManager->resetIconSubProperty(property))
+        return;
+
+    BoolBlocker block(m_updatingBrowser);
+
+    QtVariantProperty *prop = m_propertyManager->variantProperty(property);
+    int role = m_propertyToRole.value(prop);
+    if (role == ItemFlagsShadowRole)
+        prop->setValue(QVariant::fromValue((int)QListWidgetItem().flags()));
+    else
+        prop->setValue(QVariant(prop->valueType(), (void *)0));
+    prop->setModified(false);
+
+    setItemData(role, QVariant());
+    if (role == Qt::DecorationPropertyRole)
+        setItemData(Qt::DecorationRole, QVariant::fromValue(QIcon()));
+    if (role == Qt::DisplayPropertyRole)
+        setItemData(Qt::EditRole, QVariant::fromValue(QString()));
+    if (role == Qt::ToolTipPropertyRole)
+        setItemData(Qt::ToolTipRole, QVariant::fromValue(QString()));
+    if (role == Qt::StatusTipPropertyRole)
+        setItemData(Qt::StatusTipRole, QVariant::fromValue(QString()));
+    if (role == Qt::WhatsThisPropertyRole)
+        setItemData(Qt::WhatsThisRole, QVariant::fromValue(QString()));
+}
+
+void AbstractItemEditor::cacheReloaded()
+{
+    BoolBlocker block(m_updatingBrowser);
+    m_propertyManager->reloadResourceProperties();
+}
+
+void AbstractItemEditor::updateBrowser()
+{
+    BoolBlocker block(m_updatingBrowser);
+    foreach (QtVariantProperty *prop, m_properties) {
+        int role = m_propertyToRole.value(prop);
+        QVariant val = getItemData(role);
+        if (!val.isValid()) {
+            if (role == ItemFlagsShadowRole)
+                val = QVariant::fromValue((int)QListWidgetItem().flags());
+            else
+                val = QVariant((int)prop->value().userType(), (void *)0);
+            prop->setModified(false);
+        } else {
+            prop->setModified(true);
+        }
+        prop->setValue(val);
+    }
+
+    if (m_propertyBrowser->topLevelItems().isEmpty())
+        foreach (QtVariantProperty *prop, m_rootProperties)
+            m_propertyBrowser->addProperty(prop);
+}
+
+void AbstractItemEditor::injectPropertyBrowser(QWidget *parent, QWidget *widget)
+{
+    // It is impossible to design a splitter with just one widget, so we do it by hand.
+    m_propertySplitter = new QSplitter;
+    m_propertySplitter->addWidget(widget);
+    m_propertySplitter->addWidget(m_propertyBrowser);
+    m_propertySplitter->setStretchFactor(0, 1);
+    m_propertySplitter->setStretchFactor(1, 0);
+    parent->layout()->addWidget(m_propertySplitter);
+}
+
+////////////////// List editor ///////////////
+ItemListEditor::ItemListEditor(QDesignerFormWindowInterface *form, QWidget *parent)
+    : AbstractItemEditor(form, parent),
+      m_updating(false)
+{
+    ui.setupUi(this);
+
+    injectPropertyBrowser(this, ui.widget);
+    connect(ui.showPropertiesButton, SIGNAL(clicked()),
+            this, SLOT(togglePropertyBrowser()));
+    setPropertyBrowserVisible(false);
+
+    QIcon upIcon = createIconSet(QString::fromUtf8("up.png"));
+    QIcon downIcon = createIconSet(QString::fromUtf8("down.png"));
+    QIcon minusIcon = createIconSet(QString::fromUtf8("minus.png"));
+    QIcon plusIcon = createIconSet(QString::fromUtf8("plus.png"));
+    ui.moveListItemUpButton->setIcon(upIcon);
+    ui.moveListItemDownButton->setIcon(downIcon);
+    ui.newListItemButton->setIcon(plusIcon);
+    ui.deleteListItemButton->setIcon(minusIcon);
+
+    connect(iconCache(), SIGNAL(reloaded()), this, SLOT(cacheReloaded()));
+}
+
+void ItemListEditor::setupEditor(QWidget *object, PropertyDefinition *propList)
+{
+    AbstractItemEditor::setupEditor(object, propList);
+
+    if (ui.listWidget->count() > 0)
+        ui.listWidget->setCurrentRow(0);
+    else
+        updateEditor();
+}
+
+void ItemListEditor::setCurrentIndex(int idx)
+{
+    m_updating = true;
+    ui.listWidget->setCurrentRow(idx);
+    m_updating = false;
+}
+
+void ItemListEditor::on_newListItemButton_clicked()
+{
+    int row = ui.listWidget->currentRow() + 1;
+
+    QListWidgetItem *item = new QListWidgetItem(m_newItemText);
+    item->setData(Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(m_newItemText)));
+    item->setFlags(item->flags() | Qt::ItemIsEditable);
+    if (row < ui.listWidget->count())
+        ui.listWidget->insertItem(row, item);
+    else
+        ui.listWidget->addItem(item);
+    emit itemInserted(row);
+
+    ui.listWidget->setCurrentItem(item);
+    ui.listWidget->editItem(item);
+}
+
+void ItemListEditor::on_deleteListItemButton_clicked()
+{
+    int row = ui.listWidget->currentRow();
+
+    if (row != -1) {
+        delete ui.listWidget->takeItem(row);
+        emit itemDeleted(row);
+    }
+
+    if (row == ui.listWidget->count())
+        row--;
+    if (row < 0)
+        updateEditor();
+    else
+        ui.listWidget->setCurrentRow(row);
+}
+
+void ItemListEditor::on_moveListItemUpButton_clicked()
+{
+    int row = ui.listWidget->currentRow();
+    if (row <= 0)
+        return; // nothing to do
+
+    ui.listWidget->insertItem(row - 1, ui.listWidget->takeItem(row));
+    ui.listWidget->setCurrentRow(row - 1);
+    emit itemMovedUp(row);
+}
+
+void ItemListEditor::on_moveListItemDownButton_clicked()
+{
+    int row = ui.listWidget->currentRow();
+    if (row == -1 || row == ui.listWidget->count() - 1)
+        return; // nothing to do
+
+    ui.listWidget->insertItem(row + 1, ui.listWidget->takeItem(row));
+    ui.listWidget->setCurrentRow(row + 1);
+    emit itemMovedDown(row);
+}
+
+void ItemListEditor::on_listWidget_currentRowChanged()
+{
+    updateEditor();
+    if (!m_updating)
+        emit indexChanged(ui.listWidget->currentRow());
+}
+
+void ItemListEditor::on_listWidget_itemChanged(QListWidgetItem *item)
+{
+    if (m_updatingBrowser)
+        return;
+
+    PropertySheetStringValue val = qvariant_cast<PropertySheetStringValue>(item->data(Qt::DisplayPropertyRole));
+    val.setValue(item->text());
+    BoolBlocker block(m_updatingBrowser);
+    item->setData(Qt::DisplayPropertyRole, QVariant::fromValue(val));
+
+    // The checkState could change, too, but if this signal is connected,
+    // checkState is not in the list anyway, as we are editing a header item.
+    emit itemChanged(ui.listWidget->currentRow(), Qt::DisplayPropertyRole,
+                     QVariant::fromValue(val));
+    updateBrowser();
+}
+
+void ItemListEditor::togglePropertyBrowser()
+{
+    setPropertyBrowserVisible(!m_propertyBrowser->isVisible());
+}
+
+void ItemListEditor::setPropertyBrowserVisible(bool v)
+{
+    ui.showPropertiesButton->setText(v ? tr("Properties &>>") : tr("Properties &<<"));
+    m_propertyBrowser->setVisible(v);
+}
+
+void ItemListEditor::setItemData(int role, const QVariant &v)
+{
+    QListWidgetItem *item = ui.listWidget->currentItem();
+    bool reLayout = false;
+    if ((role == Qt::EditRole && (v.toString().count(QLatin1Char('\n')) != item->data(role).toString().count(QLatin1Char('\n'))))
+        || role == Qt::FontRole)
+            reLayout = true;
+    QVariant newValue = v;
+    if (role == Qt::FontRole && newValue.type() == QVariant::Font) {
+        QFont oldFont = ui.listWidget->font();
+        QFont newFont = qvariant_cast<QFont>(newValue).resolve(oldFont);
+        newValue = QVariant::fromValue(newFont);
+        item->setData(role, QVariant()); // force the right font with the current resolve mask is set (item view bug)
+    }
+    item->setData(role, newValue);
+    if (reLayout)
+        ui.listWidget->doItemsLayout();
+    emit itemChanged(ui.listWidget->currentRow(), role, newValue);
+}
+
+QVariant ItemListEditor::getItemData(int role) const
+{
+    return ui.listWidget->currentItem()->data(role);
+}
+
+void ItemListEditor::cacheReloaded()
+{
+    reloadIconResources(iconCache(), ui.listWidget);
+}
+
+void ItemListEditor::updateEditor()
+{
+    bool currentItemEnabled = false;
+
+    bool moveRowUpEnabled = false;
+    bool moveRowDownEnabled = false;
+
+    QListWidgetItem *item = ui.listWidget->currentItem();
+    if (item) {
+        currentItemEnabled = true;
+        int currentRow = ui.listWidget->currentRow();
+        if (currentRow > 0)
+            moveRowUpEnabled = true;
+        if (currentRow < ui.listWidget->count() - 1)
+            moveRowDownEnabled = true;
+    }
+
+    ui.moveListItemUpButton->setEnabled(moveRowUpEnabled);
+    ui.moveListItemDownButton->setEnabled(moveRowDownEnabled);
+    ui.deleteListItemButton->setEnabled(currentItemEnabled);
+
+    if (item)
+        updateBrowser();
+    else
+        m_propertyBrowser->clear();
+}
+} // namespace qdesigner_internal
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/itemlisteditor.h b/src/designer/src/components/taskmenu/itemlisteditor.h
new file mode 100644
index 000000000..ffacad293
--- /dev/null
+++ b/src/designer/src/components/taskmenu/itemlisteditor.h
@@ -0,0 +1,165 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef ITEMLISTEDITOR_H
+#define ITEMLISTEDITOR_H
+
+#include "ui_itemlisteditor.h"
+
+#include <QtGui/QDialog>
+
+QT_BEGIN_NAMESPACE
+
+class QDesignerFormWindowInterface;
+class QtProperty;
+class QtVariantProperty;
+class QtTreePropertyBrowser;
+class QSplitter;
+class QVBoxLayout;
+
+namespace qdesigner_internal {
+
+class DesignerIconCache;
+class DesignerPropertyManager;
+class DesignerEditorFactory;
+
+// Utility class that ensures a bool is true while in scope.
+// Courtesy of QBoolBlocker in qobject_p.h
+class BoolBlocker
+{
+public:
+    inline BoolBlocker(bool &b):block(b), reset(b){block = true;}
+    inline ~BoolBlocker(){block = reset; }
+private:
+    bool &block;
+    bool reset;
+};
+
+class AbstractItemEditor: public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit AbstractItemEditor(QDesignerFormWindowInterface *form, QWidget *parent);
+    ~AbstractItemEditor();
+
+    DesignerIconCache *iconCache() const { return m_iconCache; }
+
+    struct PropertyDefinition {
+        int role;
+        int type;
+        int (*typeFunc)();
+        const char *name;
+    };
+
+private slots:
+    void propertyChanged(QtProperty *property);
+    void resetProperty(QtProperty *property);
+    void cacheReloaded();
+
+protected:
+    void setupProperties(PropertyDefinition *propDefs);
+    void setupObject(QWidget *object);
+    void setupEditor(QWidget *object, PropertyDefinition *propDefs);
+    void injectPropertyBrowser(QWidget *parent, QWidget *widget);
+    void updateBrowser();
+    virtual void setItemData(int role, const QVariant &v) = 0;
+    virtual QVariant getItemData(int role) const = 0;
+
+    DesignerIconCache *m_iconCache;
+    DesignerPropertyManager *m_propertyManager;
+    DesignerEditorFactory *m_editorFactory;
+    QSplitter *m_propertySplitter;
+    QtTreePropertyBrowser *m_propertyBrowser;
+    QList<QtVariantProperty*> m_properties;
+    QList<QtVariantProperty*> m_rootProperties;
+    QHash<QtVariantProperty*, int> m_propertyToRole;
+    bool m_updatingBrowser;
+};
+
+class ItemListEditor: public AbstractItemEditor
+{
+    Q_OBJECT
+
+public:
+    explicit ItemListEditor(QDesignerFormWindowInterface *form, QWidget *parent);
+
+    void setupEditor(QWidget *object, PropertyDefinition *propDefs);
+    QListWidget *listWidget() const { return ui.listWidget; }
+    void setNewItemText(const QString &tpl) { m_newItemText = tpl; }
+    QString newItemText() const { return m_newItemText; }
+    void setCurrentIndex(int idx);
+
+signals:
+    void indexChanged(int idx);
+    void itemChanged(int idx, int role, const QVariant &v);
+    void itemInserted(int idx);
+    void itemDeleted(int idx);
+    void itemMovedUp(int idx);
+    void itemMovedDown(int idx);
+
+private slots:
+    void on_newListItemButton_clicked();
+    void on_deleteListItemButton_clicked();
+    void on_moveListItemUpButton_clicked();
+    void on_moveListItemDownButton_clicked();
+    void on_listWidget_currentRowChanged();
+    void on_listWidget_itemChanged(QListWidgetItem * item);
+    void togglePropertyBrowser();
+    void cacheReloaded();
+
+protected:
+    virtual void setItemData(int role, const QVariant &v);
+    virtual QVariant getItemData(int role) const;
+
+private:
+    void setPropertyBrowserVisible(bool v);
+    void updateEditor();
+    Ui::ItemListEditor ui;
+    bool m_updating;
+    QString m_newItemText;
+};
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // ITEMLISTEDITOR_H
diff --git a/src/designer/src/components/taskmenu/itemlisteditor.ui b/src/designer/src/components/taskmenu/itemlisteditor.ui
new file mode 100644
index 000000000..a13703f90
--- /dev/null
+++ b/src/designer/src/components/taskmenu/itemlisteditor.ui
@@ -0,0 +1,156 @@
+<ui version="4.0" >
+ <comment>*********************************************************************
+**
+** 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$
+**
+*********************************************************************</comment>
+ <class>qdesigner_internal::ItemListEditor</class>
+ <widget class="QWidget" name="qdesigner_internal::ItemListEditor" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>550</width>
+    <height>360</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string/>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout_2" >
+   <item>
+    <widget class="QWidget" native="1" name="widget" >
+     <layout class="QVBoxLayout" name="verticalLayout" >
+      <property name="margin" >
+       <number>0</number>
+      </property>
+      <item>
+       <widget class="QListWidget" name="listWidget" >
+        <property name="enabled" >
+         <bool>true</bool>
+        </property>
+        <property name="toolTip" >
+         <string>Items List</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="buttonsLayout" >
+        <item>
+         <widget class="QToolButton" name="newListItemButton" >
+          <property name="toolTip" >
+           <string>New Item</string>
+          </property>
+          <property name="text" >
+           <string>&amp;New</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="deleteListItemButton" >
+          <property name="toolTip" >
+           <string>Delete Item</string>
+          </property>
+          <property name="text" >
+           <string>&amp;Delete</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer>
+          <property name="orientation" >
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0" >
+           <size>
+            <width>16</width>
+            <height>10</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item>
+         <widget class="QToolButton" name="moveListItemUpButton" >
+          <property name="toolTip" >
+           <string>Move Item Up</string>
+          </property>
+          <property name="text" >
+           <string>U</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QToolButton" name="moveListItemDownButton" >
+          <property name="toolTip" >
+           <string>Move Item Down</string>
+          </property>
+          <property name="text" >
+           <string>D</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <spacer name="horizontalSpacer" >
+          <property name="orientation" >
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0" >
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item>
+         <widget class="QPushButton" name="showPropertiesButton" >
+          <property name="text" >
+           <string>Properties &amp;>></string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/src/designer/src/components/taskmenu/label_taskmenu.cpp b/src/designer/src/components/taskmenu/label_taskmenu.cpp
new file mode 100644
index 000000000..5f0acb209
--- /dev/null
+++ b/src/designer/src/components/taskmenu/label_taskmenu.cpp
@@ -0,0 +1,117 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "label_taskmenu.h"
+#include "inplace_editor.h"
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QAction>
+#include <QtGui/QStyle>
+#include <QtGui/QStyleOption>
+#include <QtGui/QTextDocument>
+
+static const char *textPropertyC = "text";
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+// -------- LabelTaskMenuInlineEditor
+class LabelTaskMenuInlineEditor : public  TaskMenuInlineEditor
+{
+public:
+    LabelTaskMenuInlineEditor(QLabel *button, QObject *parent);
+
+protected:
+    virtual QRect editRectangle() const;
+};
+
+LabelTaskMenuInlineEditor::LabelTaskMenuInlineEditor(QLabel *w, QObject *parent) :
+      TaskMenuInlineEditor(w, ValidationRichText, QLatin1String(textPropertyC), parent)
+{
+}
+
+QRect LabelTaskMenuInlineEditor::editRectangle() const
+{
+    QStyleOptionButton opt;
+    opt.init(widget());
+    return opt.rect;
+}
+
+// --------------- LabelTaskMenu
+
+LabelTaskMenu::LabelTaskMenu(QLabel *label, QObject *parent)
+    : QDesignerTaskMenu(label, parent),
+      m_label(label),
+      m_editRichTextAction(new QAction(tr("Change rich text..."), this)),
+      m_editPlainTextAction(new QAction(tr("Change plain text..."), this))
+{
+    LabelTaskMenuInlineEditor *editor = new LabelTaskMenuInlineEditor(label, this);
+    connect(m_editPlainTextAction, SIGNAL(triggered()), editor, SLOT(editText()));
+    m_taskActions.append(m_editPlainTextAction);
+
+    connect(m_editRichTextAction, SIGNAL(triggered()), this, SLOT(editRichText()));
+    m_taskActions.append(m_editRichTextAction);
+
+    QAction *sep = new QAction(this);
+    sep->setSeparator(true);
+    m_taskActions.append(sep);
+}
+
+QAction *LabelTaskMenu::preferredEditAction() const
+{
+    if (m_label->textFormat () == Qt::PlainText) return m_editPlainTextAction;
+    return Qt::mightBeRichText(m_label->text()) ? m_editRichTextAction : m_editPlainTextAction;
+}
+
+QList<QAction*> LabelTaskMenu::taskActions() const
+{
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+void LabelTaskMenu::editRichText()
+{
+    changeTextProperty(QLatin1String(textPropertyC), QString(), MultiSelectionMode, m_label->textFormat());
+}
+
+}
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/label_taskmenu.h b/src/designer/src/components/taskmenu/label_taskmenu.h
new file mode 100644
index 000000000..7f3549128
--- /dev/null
+++ b/src/designer/src/components/taskmenu/label_taskmenu.h
@@ -0,0 +1,81 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef LABEL_TASKMENU_H
+#define LABEL_TASKMENU_H
+
+#include <QtGui/QLabel>
+#include <QtCore/QPointer>
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class LabelTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit LabelTaskMenu(QLabel *button, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void editRichText();
+
+private:
+    QLabel *m_label;
+    QList<QAction*> m_taskActions;
+    QAction *m_editRichTextAction;
+    QAction *m_editPlainTextAction;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QLabel, LabelTaskMenu>  LabelTaskMenuFactory;
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // LABEL_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/layouttaskmenu.cpp b/src/designer/src/components/taskmenu/layouttaskmenu.cpp
new file mode 100644
index 000000000..10d5d7c54
--- /dev/null
+++ b/src/designer/src/components/taskmenu/layouttaskmenu.cpp
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "layouttaskmenu.h"
+#include <formlayoutmenu_p.h>
+#include <morphmenu_p.h>
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QAction>
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+// ------------ LayoutWidgetTaskMenu
+LayoutWidgetTaskMenu::LayoutWidgetTaskMenu(QLayoutWidget *lw, QObject *parent) :
+   QObject(parent),
+   m_widget(lw),
+   m_morphMenu(new qdesigner_internal::MorphMenu(this)),
+   m_formLayoutMenu(new qdesigner_internal::FormLayoutMenu(this))
+{
+}
+
+QAction *LayoutWidgetTaskMenu::preferredEditAction() const
+{
+    return m_formLayoutMenu->preferredEditAction(m_widget, m_widget->formWindow());
+}
+
+QList<QAction*> LayoutWidgetTaskMenu::taskActions() const
+{
+    QList<QAction*> rc;
+    QDesignerFormWindowInterface *fw = m_widget->formWindow();
+    m_morphMenu->populate(m_widget, fw, rc);
+    m_formLayoutMenu->populate(m_widget, fw, rc);
+    return rc;
+}
+
+// ------------- SpacerTaskMenu
+SpacerTaskMenu::SpacerTaskMenu(Spacer *, QObject *parent) :
+    QObject(parent)
+{
+}
+
+QAction *SpacerTaskMenu::preferredEditAction() const
+{
+    return 0;
+}
+
+QList<QAction*> SpacerTaskMenu::taskActions() const
+{
+    return QList<QAction*>();
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/designer/src/components/taskmenu/layouttaskmenu.h b/src/designer/src/components/taskmenu/layouttaskmenu.h
new file mode 100644
index 000000000..ca52596ee
--- /dev/null
+++ b/src/designer/src/components/taskmenu/layouttaskmenu.h
@@ -0,0 +1,93 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef LAYOUTTASKMENU_H
+#define LAYOUTTASKMENU_H
+
+#include <QtDesigner/QDesignerTaskMenuExtension>
+
+#include <qlayout_widget_p.h>
+#include <spacer_widget_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+    class FormLayoutMenu;
+    class MorphMenu;
+}
+
+// Morph menu for QLayoutWidget.
+class LayoutWidgetTaskMenu : public QObject, public QDesignerTaskMenuExtension
+{
+    Q_OBJECT
+    Q_INTERFACES(QDesignerTaskMenuExtension)
+public:
+    explicit LayoutWidgetTaskMenu(QLayoutWidget *w, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private:
+    QLayoutWidget *m_widget;
+    qdesigner_internal::MorphMenu *m_morphMenu;
+    qdesigner_internal::FormLayoutMenu *m_formLayoutMenu;
+};
+
+// Empty task menu for spacers.
+class SpacerTaskMenu : public QObject, public QDesignerTaskMenuExtension
+{
+    Q_OBJECT
+    Q_INTERFACES(QDesignerTaskMenuExtension)
+public:
+    explicit SpacerTaskMenu(Spacer *bar, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+};
+
+typedef qdesigner_internal::ExtensionFactory<QDesignerTaskMenuExtension, QLayoutWidget, LayoutWidgetTaskMenu> LayoutWidgetTaskMenuFactory;
+typedef qdesigner_internal::ExtensionFactory<QDesignerTaskMenuExtension, Spacer, SpacerTaskMenu> SpacerTaskMenuFactory;
+
+QT_END_NAMESPACE
+
+#endif // LAYOUTTASKMENU_H
diff --git a/src/designer/src/components/taskmenu/lineedit_taskmenu.cpp b/src/designer/src/components/taskmenu/lineedit_taskmenu.cpp
new file mode 100644
index 000000000..c00c493b1
--- /dev/null
+++ b/src/designer/src/components/taskmenu/lineedit_taskmenu.cpp
@@ -0,0 +1,103 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "lineedit_taskmenu.h"
+#include "inplace_editor.h"
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QAction>
+#include <QtGui/QStyle>
+#include <QtGui/QStyleOption>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+// -------- LineEditTaskMenuInlineEditor
+class LineEditTaskMenuInlineEditor : public  TaskMenuInlineEditor
+{
+public:
+    LineEditTaskMenuInlineEditor(QLineEdit *button, QObject *parent);
+
+protected:
+    virtual QRect editRectangle() const;
+};
+
+LineEditTaskMenuInlineEditor::LineEditTaskMenuInlineEditor(QLineEdit *w, QObject *parent) :
+      TaskMenuInlineEditor(w, ValidationSingleLine, QLatin1String("text"), parent)
+{
+}
+
+QRect LineEditTaskMenuInlineEditor::editRectangle() const
+{
+    QStyleOption opt;
+    opt.init(widget());
+    return opt.rect;
+}
+
+// --------------- LineEditTaskMenu
+LineEditTaskMenu::LineEditTaskMenu(QLineEdit *lineEdit, QObject *parent) :
+    QDesignerTaskMenu(lineEdit, parent),
+    m_editTextAction(new QAction(tr("Change text..."), this))
+{
+    TaskMenuInlineEditor *editor = new LineEditTaskMenuInlineEditor(lineEdit, this);
+    connect(m_editTextAction, SIGNAL(triggered()), editor, SLOT(editText()));
+    m_taskActions.append(m_editTextAction);
+
+    QAction *sep = new QAction(this);
+    sep->setSeparator(true);
+    m_taskActions.append(sep);
+}
+
+QAction *LineEditTaskMenu::preferredEditAction() const
+{
+    return m_editTextAction;
+}
+
+QList<QAction*> LineEditTaskMenu::taskActions() const
+{
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/lineedit_taskmenu.h b/src/designer/src/components/taskmenu/lineedit_taskmenu.h
new file mode 100644
index 000000000..239590bb8
--- /dev/null
+++ b/src/designer/src/components/taskmenu/lineedit_taskmenu.h
@@ -0,0 +1,74 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef LINEEDIT_TASKMENU_H
+#define LINEEDIT_TASKMENU_H
+
+#include <QtGui/QLineEdit>
+#include <QtCore/QPointer>
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+class LineEditTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit LineEditTaskMenu(QLineEdit *button, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private:
+    QList<QAction*> m_taskActions;
+    QAction *m_editTextAction;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QLineEdit, LineEditTaskMenu> LineEditTaskMenuFactory;
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // LINEEDIT_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/listwidget_taskmenu.cpp b/src/designer/src/components/taskmenu/listwidget_taskmenu.cpp
new file mode 100644
index 000000000..bd8f6b9f8
--- /dev/null
+++ b/src/designer/src/components/taskmenu/listwidget_taskmenu.cpp
@@ -0,0 +1,117 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "listwidget_taskmenu.h"
+#include "listwidgeteditor.h"
+#include "qdesigner_utils_p.h"
+#include <qdesigner_command_p.h>
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QAction>
+#include <QtGui/QStyle>
+#include <QtGui/QLineEdit>
+#include <QtGui/QStyleOption>
+
+#include <QtCore/QEvent>
+#include <QtCore/QVariant>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace qdesigner_internal;
+
+ListWidgetTaskMenu::ListWidgetTaskMenu(QListWidget *button, QObject *parent)
+    : QDesignerTaskMenu(button, parent),
+      m_listWidget(button)
+{
+    m_editItemsAction = new QAction(this);
+    m_editItemsAction->setText(tr("Edit Items..."));
+    connect(m_editItemsAction, SIGNAL(triggered()), this, SLOT(editItems()));
+    m_taskActions.append(m_editItemsAction);
+
+    QAction *sep = new QAction(this);
+    sep->setSeparator(true);
+    m_taskActions.append(sep);
+}
+
+ListWidgetTaskMenu::~ListWidgetTaskMenu()
+{
+}
+
+QAction *ListWidgetTaskMenu::preferredEditAction() const
+{
+    return m_editItemsAction;
+}
+
+QList<QAction*> ListWidgetTaskMenu::taskActions() const
+{
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+void ListWidgetTaskMenu::editItems()
+{
+    m_formWindow = QDesignerFormWindowInterface::findFormWindow(m_listWidget);
+    if (m_formWindow.isNull())
+        return;
+
+    Q_ASSERT(m_listWidget != 0);
+
+    ListWidgetEditor dlg(m_formWindow, m_listWidget->window());
+    ListContents oldItems = dlg.fillContentsFromListWidget(m_listWidget);
+    if (dlg.exec() == QDialog::Accepted) {
+        ListContents items = dlg.contents();
+        if (items != oldItems) {
+            ChangeListContentsCommand *cmd = new ChangeListContentsCommand(m_formWindow);
+            cmd->init(m_listWidget, oldItems, items);
+            cmd->setText(tr("Change List Contents"));
+            m_formWindow->commandHistory()->push(cmd);
+        }
+    }
+}
+
+void ListWidgetTaskMenu::updateSelection()
+{
+    if (m_editor)
+        m_editor->deleteLater();
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/listwidget_taskmenu.h b/src/designer/src/components/taskmenu/listwidget_taskmenu.h
new file mode 100644
index 000000000..e7e527a38
--- /dev/null
+++ b/src/designer/src/components/taskmenu/listwidget_taskmenu.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef LISTWIDGET_TASKMENU_H
+#define LISTWIDGET_TASKMENU_H
+
+#include <QtGui/QListWidget>
+#include <QtCore/QPointer>
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QLineEdit;
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class ListWidgetTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit ListWidgetTaskMenu(QListWidget *button, QObject *parent = 0);
+    virtual ~ListWidgetTaskMenu();
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void editItems();
+    void updateSelection();
+
+private:
+    QListWidget *m_listWidget;
+    QPointer<QDesignerFormWindowInterface> m_formWindow;
+    QPointer<QLineEdit> m_editor;
+    mutable QList<QAction*> m_taskActions;
+    QAction *m_editItemsAction;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QListWidget, ListWidgetTaskMenu> ListWidgetTaskMenuFactory;
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // LISTWIDGET_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/listwidgeteditor.cpp b/src/designer/src/components/taskmenu/listwidgeteditor.cpp
new file mode 100644
index 000000000..7c81ea47e
--- /dev/null
+++ b/src/designer/src/components/taskmenu/listwidgeteditor.cpp
@@ -0,0 +1,138 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "listwidgeteditor.h"
+#include <designerpropertymanager.h>
+#include <abstractformbuilder.h>
+
+#include <QtDesigner/private/abstractsettings_p.h>
+#include <QtDesigner/QDesignerFormEditorInterface>
+
+#include <QtGui/QComboBox>
+#include <QtGui/QGroupBox>
+#include <QtGui/QDialogButtonBox>
+
+QT_BEGIN_NAMESPACE
+
+using namespace qdesigner_internal;
+
+ListWidgetEditor::ListWidgetEditor(QDesignerFormWindowInterface *form,
+                                   QWidget *parent)
+    : QDialog(parent)
+{
+    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+    QDialogButtonBox *buttonBox = new QDialogButtonBox;
+    buttonBox->setStandardButtons(QDialogButtonBox::Cancel|QDialogButtonBox::Ok);
+    connect(buttonBox, SIGNAL(accepted()), SLOT(accept()));
+    connect(buttonBox, SIGNAL(rejected()), SLOT(reject()));
+
+    m_itemsEditor = new ItemListEditor(form, 0);
+    m_itemsEditor->layout()->setMargin(0);
+    m_itemsEditor->setNewItemText(tr("New Item"));
+
+    QFrame *sep = new QFrame;
+    sep->setFrameStyle(QFrame::HLine | QFrame::Sunken);
+
+    QBoxLayout *box = new QVBoxLayout(this);
+    box->addWidget(m_itemsEditor);
+    box->addWidget(sep);
+    box->addWidget(buttonBox);
+
+    // Numbers copied from itemlisteditor.ui
+    // (Automatic resizing doesn't work because ui has parent).
+    resize(550, 360);
+}
+
+static AbstractItemEditor::PropertyDefinition listBoxPropList[] = {
+    { Qt::DisplayPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "text" },
+    { Qt::DecorationPropertyRole, 0, DesignerPropertyManager::designerIconTypeId, "icon" },
+    { Qt::ToolTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "toolTip" },
+    { Qt::StatusTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "statusTip" },
+    { Qt::WhatsThisPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "whatsThis" },
+    { Qt::FontRole, QVariant::Font, 0, "font" },
+    { Qt::TextAlignmentRole, 0, DesignerPropertyManager::designerAlignmentTypeId, "textAlignment" },
+    { Qt::BackgroundRole, QVariant::Brush, 0, "background" },
+    { Qt::ForegroundRole, QVariant::Brush, 0, "foreground" },
+    { ItemFlagsShadowRole, 0, QtVariantPropertyManager::flagTypeId, "flags" },
+    { Qt::CheckStateRole, 0, QtVariantPropertyManager::enumTypeId, "checkState" },
+    { 0, 0, 0, 0 }
+};
+
+ListContents ListWidgetEditor::fillContentsFromListWidget(QListWidget *listWidget)
+{
+    setWindowTitle(tr("Edit List Widget"));
+
+    ListContents retVal;
+    retVal.createFromListWidget(listWidget, false);
+    retVal.applyToListWidget(m_itemsEditor->listWidget(), m_itemsEditor->iconCache(), true);
+
+    m_itemsEditor->setupEditor(listWidget, listBoxPropList);
+
+    return retVal;
+}
+
+static AbstractItemEditor::PropertyDefinition comboBoxPropList[] = {
+    { Qt::DisplayPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "text" },
+    { Qt::DecorationPropertyRole, 0, DesignerPropertyManager::designerIconTypeId, "icon" },
+    { 0, 0, 0, 0 }
+};
+
+ListContents ListWidgetEditor::fillContentsFromComboBox(QComboBox *comboBox)
+{
+    setWindowTitle(tr("Edit Combobox"));
+
+    ListContents retVal;
+    retVal.createFromComboBox(comboBox);
+    retVal.applyToListWidget(m_itemsEditor->listWidget(), m_itemsEditor->iconCache(), true);
+
+    m_itemsEditor->setupEditor(comboBox, comboBoxPropList);
+
+    return retVal;
+}
+
+ListContents ListWidgetEditor::contents() const
+{
+    ListContents retVal;
+    retVal.createFromListWidget(m_itemsEditor->listWidget(), true);
+    return retVal;
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/listwidgeteditor.h b/src/designer/src/components/taskmenu/listwidgeteditor.h
new file mode 100644
index 000000000..12d0591f2
--- /dev/null
+++ b/src/designer/src/components/taskmenu/listwidgeteditor.h
@@ -0,0 +1,78 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef LISTWIDGETEDITOR_H
+#define LISTWIDGETEDITOR_H
+
+#include "itemlisteditor.h"
+#include <qdesigner_command_p.h>
+
+#include <QtGui/QWidget>
+
+QT_BEGIN_NAMESPACE
+
+class QListWidget;
+class QComboBox;
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class ListWidgetEditor: public QDialog
+{
+    Q_OBJECT
+
+public:
+    ListWidgetEditor(QDesignerFormWindowInterface *form,
+                     QWidget *parent);
+
+    ListContents fillContentsFromListWidget(QListWidget *listWidget);
+    ListContents fillContentsFromComboBox(QComboBox *comboBox);
+    ListContents contents() const;
+
+private:
+    ItemListEditor *m_itemsEditor;
+};
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // LISTWIDGETEDITOR_H
diff --git a/src/designer/src/components/taskmenu/menutaskmenu.cpp b/src/designer/src/components/taskmenu/menutaskmenu.cpp
new file mode 100644
index 000000000..cbcecb122
--- /dev/null
+++ b/src/designer/src/components/taskmenu/menutaskmenu.cpp
@@ -0,0 +1,107 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "menutaskmenu.h"
+
+#include <promotiontaskmenu_p.h>
+
+#include <QtGui/QAction>
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+    // ------------ MenuTaskMenu
+    MenuTaskMenu::MenuTaskMenu(QDesignerMenu *menu, QObject *parent) :
+       QObject(parent),
+       m_menu(menu),
+       m_removeAction(new QAction(tr("Remove"), this)),
+       m_promotionTaskMenu(new PromotionTaskMenu(menu, PromotionTaskMenu::ModeSingleWidget, this))
+    {
+        connect(m_removeAction, SIGNAL(triggered()), this, SLOT(removeMenu()));
+    }
+
+    QAction *MenuTaskMenu::preferredEditAction() const
+    {
+        return 0;
+    }
+
+    QList<QAction*> MenuTaskMenu::taskActions() const
+    {
+        QList<QAction*> rc;
+        rc.push_back(m_removeAction);
+        m_promotionTaskMenu->addActions(PromotionTaskMenu::LeadingSeparator, rc);
+        return rc;
+    }
+
+    void MenuTaskMenu::removeMenu()
+    {
+        // Are we on a menu bar or on a menu?
+        QWidget *pw = m_menu->parentWidget();
+        if (QDesignerMenuBar *mb = qobject_cast<QDesignerMenuBar *>(pw)) {
+            mb->deleteMenuAction(m_menu->menuAction());
+            return;
+        }
+        if (QDesignerMenu *m = qobject_cast<QDesignerMenu *>(pw)) {
+            m->deleteAction(m_menu->menuAction());
+        }
+    }
+
+    // ------------- MenuBarTaskMenu
+    MenuBarTaskMenu::MenuBarTaskMenu(QDesignerMenuBar *bar, QObject *parent) :
+        QObject(parent),
+        m_bar(bar)
+    {
+    }
+
+    QAction *MenuBarTaskMenu::preferredEditAction() const
+    {
+        return 0;
+    }
+
+    QList<QAction*> MenuBarTaskMenu::taskActions() const
+    {
+        return m_bar->contextMenuActions();
+    }
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/designer/src/components/taskmenu/menutaskmenu.h b/src/designer/src/components/taskmenu/menutaskmenu.h
new file mode 100644
index 000000000..35cb061b4
--- /dev/null
+++ b/src/designer/src/components/taskmenu/menutaskmenu.h
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef MENUTASKMENU_H
+#define MENUTASKMENU_H
+
+#include <QtDesigner/QDesignerTaskMenuExtension>
+
+#include <qdesigner_menu_p.h>
+#include <qdesigner_menubar_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+    class PromotionTaskMenu;
+
+// The QMenu task menu provides promotion and a remove option. The actual
+// menu context options are not forwarded since they make only sense 
+// when a menu is being edited/visible.
+
+class MenuTaskMenu : public QObject, public QDesignerTaskMenuExtension
+{
+    Q_OBJECT
+    Q_INTERFACES(QDesignerTaskMenuExtension)
+public:
+    explicit MenuTaskMenu(QDesignerMenu *menu, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void removeMenu();
+
+private:
+    QDesignerMenu *m_menu;
+    QAction *m_removeAction;
+    PromotionTaskMenu *m_promotionTaskMenu;
+};
+
+// The QMenuBar task menu forwards the actions of QDesignerMenuBar,
+// making them available in the object inspector.
+
+class MenuBarTaskMenu : public QObject, public QDesignerTaskMenuExtension
+{
+    Q_OBJECT
+    Q_INTERFACES(QDesignerTaskMenuExtension)
+public:
+    explicit MenuBarTaskMenu(QDesignerMenuBar *bar, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private:
+    QDesignerMenuBar *m_bar;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QDesignerMenu, MenuTaskMenu> MenuTaskMenuFactory;
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QDesignerMenuBar, MenuBarTaskMenu> MenuBarTaskMenuFactory;
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // MENUTASKMENU_H
diff --git a/src/designer/src/components/taskmenu/tablewidget_taskmenu.cpp b/src/designer/src/components/taskmenu/tablewidget_taskmenu.cpp
new file mode 100644
index 000000000..e98714f62
--- /dev/null
+++ b/src/designer/src/components/taskmenu/tablewidget_taskmenu.cpp
@@ -0,0 +1,115 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "tablewidget_taskmenu.h"
+#include "tablewidgeteditor.h"
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QTableWidget>
+#include <QtGui/QAction>
+#include <QtGui/QLineEdit>
+#include <QtGui/QStyle>
+#include <QtGui/QStyleOption>
+
+#include <QtCore/QEvent>
+#include <QtCore/QVariant>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace qdesigner_internal;
+
+TableWidgetTaskMenu::TableWidgetTaskMenu(QTableWidget *button, QObject *parent)
+    : QDesignerTaskMenu(button, parent),
+      m_tableWidget(button),
+      m_editItemsAction(new QAction(tr("Edit Items..."), this))
+{
+    connect(m_editItemsAction, SIGNAL(triggered()), this, SLOT(editItems()));
+    m_taskActions.append(m_editItemsAction);
+
+    QAction *sep = new QAction(this);
+    sep->setSeparator(true);
+    m_taskActions.append(sep);
+}
+
+
+TableWidgetTaskMenu::~TableWidgetTaskMenu()
+{
+}
+
+QAction *TableWidgetTaskMenu::preferredEditAction() const
+{
+    return m_editItemsAction;
+}
+
+QList<QAction*> TableWidgetTaskMenu::taskActions() const
+{
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+void TableWidgetTaskMenu::editItems()
+{
+    m_formWindow = QDesignerFormWindowInterface::findFormWindow(m_tableWidget);
+    if (m_formWindow.isNull())
+        return;
+
+    Q_ASSERT(m_tableWidget != 0);
+
+    TableWidgetEditorDialog dlg(m_formWindow, m_tableWidget->window());
+    TableWidgetContents oldCont = dlg.fillContentsFromTableWidget(m_tableWidget);
+    if (dlg.exec() == QDialog::Accepted) {
+        TableWidgetContents newCont = dlg.contents();
+        if (newCont != oldCont) {
+            ChangeTableContentsCommand *cmd = new ChangeTableContentsCommand(m_formWindow);
+            cmd->init(m_tableWidget, oldCont, newCont);
+            m_formWindow->commandHistory()->push(cmd);
+        }
+    }
+}
+
+void TableWidgetTaskMenu::updateSelection()
+{
+    if (m_editor)
+        m_editor->deleteLater();
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/tablewidget_taskmenu.h b/src/designer/src/components/taskmenu/tablewidget_taskmenu.h
new file mode 100644
index 000000000..cbf71fea6
--- /dev/null
+++ b/src/designer/src/components/taskmenu/tablewidget_taskmenu.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TABLEWIDGET_TASKMENU_H
+#define TABLEWIDGET_TASKMENU_H
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+#include <QtGui/QTableWidget>
+#include <QtCore/QPointer>
+
+QT_BEGIN_NAMESPACE
+
+class QLineEdit;
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class TableWidgetTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit TableWidgetTaskMenu(QTableWidget *button, QObject *parent = 0);
+    virtual ~TableWidgetTaskMenu();
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void editItems();
+    void updateSelection();
+
+private:
+    QTableWidget *m_tableWidget;
+    QPointer<QDesignerFormWindowInterface> m_formWindow;
+    QPointer<QLineEdit> m_editor;
+    mutable QList<QAction*> m_taskActions;
+    QAction *m_editItemsAction;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QTableWidget, TableWidgetTaskMenu> TableWidgetTaskMenuFactory;
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // TABLEWIDGET_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/tablewidgeteditor.cpp b/src/designer/src/components/taskmenu/tablewidgeteditor.cpp
new file mode 100644
index 000000000..35f1a0e49
--- /dev/null
+++ b/src/designer/src/components/taskmenu/tablewidgeteditor.cpp
@@ -0,0 +1,450 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "tablewidgeteditor.h"
+#include <abstractformbuilder.h>
+#include <iconloader_p.h>
+#include <qdesigner_command_p.h>
+#include "formwindowbase_p.h"
+#include "qdesigner_utils_p.h"
+#include <designerpropertymanager.h>
+#include <qttreepropertybrowser.h>
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+#include <QtDesigner/QDesignerFormEditorInterface>
+#include <QtDesigner/QDesignerIconCacheInterface>
+#include <QtCore/QDir>
+#include <QtCore/QQueue>
+#include <QtCore/QTextStream>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+TableWidgetEditor::TableWidgetEditor(QDesignerFormWindowInterface *form, QDialog *dialog)
+    : AbstractItemEditor(form, 0), m_updatingBrowser(false)
+{
+    m_columnEditor = new ItemListEditor(form, this);
+    m_columnEditor->setObjectName(QLatin1String("columnEditor"));
+    m_columnEditor->setNewItemText(tr("New Column"));
+    m_rowEditor = new ItemListEditor(form, this);
+    m_rowEditor->setObjectName(QLatin1String("rowEditor"));
+    m_rowEditor->setNewItemText(tr("New Row"));
+    ui.setupUi(dialog);
+
+    injectPropertyBrowser(ui.itemsTab, ui.widget);
+    connect(ui.showPropertiesButton, SIGNAL(clicked()),
+            this, SLOT(togglePropertyBrowser()));
+    setPropertyBrowserVisible(false);
+
+    ui.tabWidget->insertTab(0, m_columnEditor, tr("&Columns"));
+    ui.tabWidget->insertTab(1, m_rowEditor, tr("&Rows"));
+    ui.tabWidget->setCurrentIndex(0);
+    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+
+    ui.tableWidget->setSelectionMode(QAbstractItemView::SingleSelection);
+
+    connect(iconCache(), SIGNAL(reloaded()), this, SLOT(cacheReloaded()));
+
+    connect(ui.tableWidget, SIGNAL(currentCellChanged(int,int,int,int)),
+            this, SLOT(on_tableWidget_currentCellChanged(int,int,int,int)));
+    connect(ui.tableWidget, SIGNAL(itemChanged(QTableWidgetItem*)),
+            this, SLOT(on_tableWidget_itemChanged(QTableWidgetItem*)));
+    connect(m_columnEditor, SIGNAL(indexChanged(int)),
+            this, SLOT(on_columnEditor_indexChanged(int)));
+    connect(m_columnEditor, SIGNAL(itemChanged(int,int,QVariant)),
+            this, SLOT(on_columnEditor_itemChanged(int,int,QVariant)));
+    connect(m_columnEditor, SIGNAL(itemInserted(int)),
+            this, SLOT(on_columnEditor_itemInserted(int)));
+    connect(m_columnEditor, SIGNAL(itemDeleted(int)),
+            this, SLOT(on_columnEditor_itemDeleted(int)));
+    connect(m_columnEditor, SIGNAL(itemMovedUp(int)),
+            this, SLOT(on_columnEditor_itemMovedUp(int)));
+    connect(m_columnEditor, SIGNAL(itemMovedDown(int)),
+            this, SLOT(on_columnEditor_itemMovedDown(int)));
+
+    connect(m_rowEditor, SIGNAL(indexChanged(int)),
+            this, SLOT(on_rowEditor_indexChanged(int)));
+    connect(m_rowEditor, SIGNAL(itemChanged(int,int,QVariant)),
+            this, SLOT(on_rowEditor_itemChanged(int,int,QVariant)));
+    connect(m_rowEditor, SIGNAL(itemInserted(int)),
+            this, SLOT(on_rowEditor_itemInserted(int)));
+    connect(m_rowEditor, SIGNAL(itemDeleted(int)),
+            this, SLOT(on_rowEditor_itemDeleted(int)));
+    connect(m_rowEditor, SIGNAL(itemMovedUp(int)),
+            this, SLOT(on_rowEditor_itemMovedUp(int)));
+    connect(m_rowEditor, SIGNAL(itemMovedDown(int)),
+            this, SLOT(on_rowEditor_itemMovedDown(int)));
+}
+
+static AbstractItemEditor::PropertyDefinition tableHeaderPropList[] = {
+    { Qt::DisplayPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "text" },
+    { Qt::DecorationPropertyRole, 0, DesignerPropertyManager::designerIconTypeId, "icon" },
+    { Qt::ToolTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "toolTip" },
+//    { Qt::StatusTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "statusTip" },
+    { Qt::WhatsThisPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "whatsThis" },
+    { Qt::FontRole, QVariant::Font, 0, "font" },
+    { Qt::TextAlignmentRole, 0, DesignerPropertyManager::designerAlignmentTypeId, "textAlignment" },
+    { Qt::BackgroundRole, QVariant::Color, 0, "background" },
+    { Qt::ForegroundRole, QVariant::Brush, 0, "foreground" },
+    { 0, 0, 0, 0 }
+};
+
+static AbstractItemEditor::PropertyDefinition tableItemPropList[] = {
+    { Qt::DisplayPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "text" },
+    { Qt::DecorationPropertyRole, 0, DesignerPropertyManager::designerIconTypeId, "icon" },
+    { Qt::ToolTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "toolTip" },
+//    { Qt::StatusTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "statusTip" },
+    { Qt::WhatsThisPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "whatsThis" },
+    { Qt::FontRole, QVariant::Font, 0, "font" },
+    { Qt::TextAlignmentRole, 0, DesignerPropertyManager::designerAlignmentTypeId, "textAlignment" },
+    { Qt::BackgroundRole, QVariant::Brush, 0, "background" },
+    { Qt::ForegroundRole, QVariant::Brush, 0, "foreground" },
+    { ItemFlagsShadowRole, 0, QtVariantPropertyManager::flagTypeId, "flags" },
+    { Qt::CheckStateRole, 0, QtVariantPropertyManager::enumTypeId, "checkState" },
+    { 0, 0, 0, 0 }
+};
+
+TableWidgetContents TableWidgetEditor::fillContentsFromTableWidget(QTableWidget *tableWidget)
+{
+    TableWidgetContents tblCont;
+    tblCont.fromTableWidget(tableWidget, false);
+    tblCont.applyToTableWidget(ui.tableWidget, iconCache(), true);
+
+    tblCont.m_verticalHeader.applyToListWidget(m_rowEditor->listWidget(), iconCache(), true);
+    m_rowEditor->setupEditor(tableWidget, tableHeaderPropList);
+
+    tblCont.m_horizontalHeader.applyToListWidget(m_columnEditor->listWidget(), iconCache(), true);
+    m_columnEditor->setupEditor(tableWidget, tableHeaderPropList);
+
+    setupEditor(tableWidget, tableItemPropList);
+    if (ui.tableWidget->columnCount() > 0 && ui.tableWidget->rowCount() > 0)
+        ui.tableWidget->setCurrentCell(0, 0);
+
+    updateEditor();
+
+    return tblCont;
+}
+
+TableWidgetContents TableWidgetEditor::contents() const
+{
+    TableWidgetContents retVal;
+    retVal.fromTableWidget(ui.tableWidget, true);
+    return retVal;
+}
+
+void TableWidgetEditor::setItemData(int role, const QVariant &v)
+{
+    QTableWidgetItem *item = ui.tableWidget->currentItem();
+    BoolBlocker block(m_updatingBrowser);
+    if (!item) {
+        item = new QTableWidgetItem;
+        ui.tableWidget->setItem(ui.tableWidget->currentRow(), ui.tableWidget->currentColumn(), item);
+    }
+    QVariant newValue = v;
+    if (role == Qt::FontRole && newValue.type() == QVariant::Font) {
+        QFont oldFont = ui.tableWidget->font();
+        QFont newFont = qvariant_cast<QFont>(newValue).resolve(oldFont);
+        newValue = QVariant::fromValue(newFont);
+        item->setData(role, QVariant()); // force the right font with the current resolve mask is set (item view bug)
+    }
+    item->setData(role, newValue);
+}
+
+QVariant TableWidgetEditor::getItemData(int role) const
+{
+    QTableWidgetItem *item = ui.tableWidget->currentItem();
+    if (!item)
+        return QVariant();
+    return item->data(role);
+}
+
+void TableWidgetEditor::on_tableWidget_currentCellChanged(int currentRow, int currentCol, int, int /* XXX remove me */)
+{
+    m_rowEditor->setCurrentIndex(currentRow);
+    m_columnEditor->setCurrentIndex(currentCol);
+    updateBrowser();
+}
+
+void TableWidgetEditor::on_tableWidget_itemChanged(QTableWidgetItem *item)
+{
+    if (m_updatingBrowser)
+        return;
+
+    PropertySheetStringValue val = qvariant_cast<PropertySheetStringValue>(item->data(Qt::DisplayPropertyRole));
+    val.setValue(item->text());
+    BoolBlocker block(m_updatingBrowser);
+    item->setData(Qt::DisplayPropertyRole, QVariant::fromValue(val));
+
+    updateBrowser();
+}
+
+void TableWidgetEditor::on_columnEditor_indexChanged(int col)
+{
+    ui.tableWidget->setCurrentCell(ui.tableWidget->currentRow(), col);
+}
+
+void TableWidgetEditor::on_columnEditor_itemChanged(int idx, int role, const QVariant &v)
+{
+    ui.tableWidget->horizontalHeaderItem(idx)->setData(role, v);
+}
+
+void TableWidgetEditor::on_rowEditor_indexChanged(int col)
+{
+    ui.tableWidget->setCurrentCell(col, ui.tableWidget->currentColumn());
+}
+
+void TableWidgetEditor::on_rowEditor_itemChanged(int idx, int role, const QVariant &v)
+{
+    ui.tableWidget->verticalHeaderItem(idx)->setData(role, v);
+}
+
+void TableWidgetEditor::setPropertyBrowserVisible(bool v)
+{
+    ui.showPropertiesButton->setText(v ? tr("Properties &>>") : tr("Properties &<<"));
+    m_propertyBrowser->setVisible(v);
+}
+
+void TableWidgetEditor::togglePropertyBrowser()
+{
+    setPropertyBrowserVisible(!m_propertyBrowser->isVisible());
+}
+
+void TableWidgetEditor::updateEditor()
+{
+    const bool wasEnabled = ui.tabWidget->isTabEnabled(2);
+    const bool isEnabled = ui.tableWidget->columnCount() && ui.tableWidget->rowCount();
+    ui.tabWidget->setTabEnabled(2, isEnabled);
+    if (!wasEnabled && isEnabled)
+        ui.tableWidget->setCurrentCell(0, 0);
+
+    QMetaObject::invokeMethod(ui.tableWidget, "updateGeometries");
+    ui.tableWidget->viewport()->update();
+}
+
+void TableWidgetEditor::moveColumnsLeft(int fromColumn, int toColumn)
+{
+    if (fromColumn >= toColumn)
+        return;
+
+    QTableWidgetItem *lastItem = ui.tableWidget->takeHorizontalHeaderItem(toColumn);
+    for (int i = toColumn; i > fromColumn; i--) {
+        ui.tableWidget->setHorizontalHeaderItem(i,
+                    ui.tableWidget->takeHorizontalHeaderItem(i - 1));
+    }
+    ui.tableWidget->setHorizontalHeaderItem(fromColumn, lastItem);
+
+    for (int i = 0; i < ui.tableWidget->rowCount(); i++) {
+        QTableWidgetItem *lastItem = ui.tableWidget->takeItem(i, toColumn);
+        for (int j = toColumn; j > fromColumn; j--)
+            ui.tableWidget->setItem(i, j, ui.tableWidget->takeItem(i, j - 1));
+        ui.tableWidget->setItem(i, fromColumn, lastItem);
+    }
+}
+
+void TableWidgetEditor::moveColumnsRight(int fromColumn, int toColumn)
+{
+    if (fromColumn >= toColumn)
+        return;
+
+    QTableWidgetItem *lastItem = ui.tableWidget->takeHorizontalHeaderItem(fromColumn);
+    for (int i = fromColumn; i < toColumn; i++) {
+        ui.tableWidget->setHorizontalHeaderItem(i,
+                    ui.tableWidget->takeHorizontalHeaderItem(i + 1));
+    }
+    ui.tableWidget->setHorizontalHeaderItem(toColumn, lastItem);
+
+    for (int i = 0; i < ui.tableWidget->rowCount(); i++) {
+        QTableWidgetItem *lastItem = ui.tableWidget->takeItem(i, fromColumn);
+        for (int j = fromColumn; j < toColumn; j++)
+            ui.tableWidget->setItem(i, j, ui.tableWidget->takeItem(i, j + 1));
+        ui.tableWidget->setItem(i, toColumn, lastItem);
+    }
+}
+
+void TableWidgetEditor::moveRowsDown(int fromRow, int toRow)
+{
+    if (fromRow >= toRow)
+        return;
+
+    QTableWidgetItem *lastItem = ui.tableWidget->takeVerticalHeaderItem(toRow);
+    for (int i = toRow; i > fromRow; i--) {
+        ui.tableWidget->setVerticalHeaderItem(i,
+                    ui.tableWidget->takeVerticalHeaderItem(i - 1));
+    }
+    ui.tableWidget->setVerticalHeaderItem(fromRow, lastItem);
+
+    for (int i = 0; i < ui.tableWidget->columnCount(); i++) {
+        QTableWidgetItem *lastItem = ui.tableWidget->takeItem(toRow, i);
+        for (int j = toRow; j > fromRow; j--)
+            ui.tableWidget->setItem(j, i, ui.tableWidget->takeItem(j - 1, i));
+        ui.tableWidget->setItem(fromRow, i, lastItem);
+    }
+}
+
+void TableWidgetEditor::moveRowsUp(int fromRow, int toRow)
+{
+    if (fromRow >= toRow)
+        return;
+
+    QTableWidgetItem *lastItem = ui.tableWidget->takeVerticalHeaderItem(fromRow);
+    for (int i = fromRow; i < toRow; i++) {
+        ui.tableWidget->setVerticalHeaderItem(i,
+                    ui.tableWidget->takeVerticalHeaderItem(i + 1));
+    }
+    ui.tableWidget->setVerticalHeaderItem(toRow, lastItem);
+
+    for (int i = 0; i < ui.tableWidget->columnCount(); i++) {
+        QTableWidgetItem *lastItem = ui.tableWidget->takeItem(fromRow, i);
+        for (int j = fromRow; j < toRow; j++)
+            ui.tableWidget->setItem(j, i, ui.tableWidget->takeItem(j + 1, i));
+        ui.tableWidget->setItem(toRow, i, lastItem);
+    }
+}
+
+void TableWidgetEditor::on_columnEditor_itemInserted(int idx)
+{
+    const int columnCount = ui.tableWidget->columnCount();
+    ui.tableWidget->setColumnCount(columnCount + 1);
+
+    QTableWidgetItem *newItem = new QTableWidgetItem(m_columnEditor->newItemText());
+    newItem->setData(Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(m_columnEditor->newItemText())));
+    ui.tableWidget->setHorizontalHeaderItem(columnCount, newItem);
+
+    moveColumnsLeft(idx, columnCount);
+
+    int row = ui.tableWidget->currentRow();
+    if (row >= 0)
+        ui.tableWidget->setCurrentCell(row, idx);
+
+    updateEditor();
+}
+
+void TableWidgetEditor::on_columnEditor_itemDeleted(int idx)
+{
+    const int columnCount = ui.tableWidget->columnCount();
+
+    moveColumnsRight(idx, columnCount - 1);
+    ui.tableWidget->setColumnCount(columnCount - 1);
+
+    updateEditor();
+}
+
+void TableWidgetEditor::on_columnEditor_itemMovedUp(int idx)
+{
+    moveColumnsRight(idx - 1, idx);
+
+    ui.tableWidget->setCurrentCell(ui.tableWidget->currentRow(), idx - 1);
+}
+
+void TableWidgetEditor::on_columnEditor_itemMovedDown(int idx)
+{
+    moveColumnsLeft(idx, idx + 1);
+
+    ui.tableWidget->setCurrentCell(ui.tableWidget->currentRow(), idx + 1);
+}
+
+void TableWidgetEditor::on_rowEditor_itemInserted(int idx)
+{
+    const int rowCount = ui.tableWidget->rowCount();
+    ui.tableWidget->setRowCount(rowCount + 1);
+
+    QTableWidgetItem *newItem = new QTableWidgetItem(m_rowEditor->newItemText());
+    newItem->setData(Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(m_rowEditor->newItemText())));
+    ui.tableWidget->setVerticalHeaderItem(rowCount, newItem);
+
+    moveRowsDown(idx, rowCount);
+
+    int col = ui.tableWidget->currentColumn();
+    if (col >= 0)
+        ui.tableWidget->setCurrentCell(idx, col);
+
+    updateEditor();
+}
+
+void TableWidgetEditor::on_rowEditor_itemDeleted(int idx)
+{
+    const int rowCount = ui.tableWidget->rowCount();
+
+    moveRowsUp(idx, rowCount - 1);
+    ui.tableWidget->setRowCount(rowCount - 1);
+
+    updateEditor();
+}
+
+void TableWidgetEditor::on_rowEditor_itemMovedUp(int idx)
+{
+    moveRowsUp(idx - 1, idx);
+
+    ui.tableWidget->setCurrentCell(idx - 1, ui.tableWidget->currentColumn());
+}
+
+void TableWidgetEditor::on_rowEditor_itemMovedDown(int idx)
+{
+    moveRowsDown(idx, idx + 1);
+
+    ui.tableWidget->setCurrentCell(idx + 1, ui.tableWidget->currentColumn());
+}
+
+void TableWidgetEditor::cacheReloaded()
+{
+    reloadIconResources(iconCache(), ui.tableWidget);
+}
+
+TableWidgetEditorDialog::TableWidgetEditorDialog(QDesignerFormWindowInterface *form, QWidget *parent) :
+    QDialog(parent), m_editor(form, this)
+{
+    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+}
+
+TableWidgetContents TableWidgetEditorDialog::fillContentsFromTableWidget(QTableWidget *tableWidget)
+{
+    return m_editor.fillContentsFromTableWidget(tableWidget);
+}
+
+TableWidgetContents TableWidgetEditorDialog::contents() const
+{
+    return m_editor.contents();
+}
+
+} // namespace qdesigner_internal
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/tablewidgeteditor.h b/src/designer/src/components/taskmenu/tablewidgeteditor.h
new file mode 100644
index 000000000..1d5ad1f57
--- /dev/null
+++ b/src/designer/src/components/taskmenu/tablewidgeteditor.h
@@ -0,0 +1,130 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TABLEWIDGETEDITOR_H
+#define TABLEWIDGETEDITOR_H
+
+#include "ui_tablewidgeteditor.h"
+
+#include "listwidgeteditor.h"
+
+#include <QtGui/QDialog>
+
+QT_BEGIN_NAMESPACE
+
+class QTableWidget;
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class FormWindowBase;
+class PropertySheetIconValue;
+
+class TableWidgetEditor: public AbstractItemEditor
+{
+    Q_OBJECT
+public:
+    explicit TableWidgetEditor(QDesignerFormWindowInterface *form, QDialog *dialog);
+
+    TableWidgetContents fillContentsFromTableWidget(QTableWidget *tableWidget);
+    TableWidgetContents contents() const;
+
+private slots:
+
+    void on_tableWidget_currentCellChanged(int currentRow, int currnetCol, int, int);
+    void on_tableWidget_itemChanged(QTableWidgetItem *item);
+
+    void on_columnEditor_indexChanged(int idx);
+    void on_columnEditor_itemChanged(int idx, int role, const QVariant &v);
+
+    void on_columnEditor_itemInserted(int idx);
+    void on_columnEditor_itemDeleted(int idx);
+    void on_columnEditor_itemMovedUp(int idx);
+    void on_columnEditor_itemMovedDown(int idx);
+
+    void on_rowEditor_indexChanged(int idx);
+    void on_rowEditor_itemChanged(int idx, int role, const QVariant &v);
+
+    void on_rowEditor_itemInserted(int idx);
+    void on_rowEditor_itemDeleted(int idx);
+    void on_rowEditor_itemMovedUp(int idx);
+    void on_rowEditor_itemMovedDown(int idx);
+
+    void togglePropertyBrowser();
+
+    void cacheReloaded();
+
+protected:
+    virtual void setItemData(int role, const QVariant &v);
+    virtual QVariant getItemData(int role) const;
+
+private:
+    void setPropertyBrowserVisible(bool v);
+    void updateEditor();
+    void moveColumnsLeft(int fromColumn, int toColumn);
+    void moveColumnsRight(int fromColumn, int toColumn);
+    void moveRowsUp(int fromRow, int toRow);
+    void moveRowsDown(int fromRow, int toRow);
+
+    Ui::TableWidgetEditor ui;
+    ItemListEditor *m_rowEditor;
+    ItemListEditor *m_columnEditor;
+    bool m_updatingBrowser;
+};
+
+class TableWidgetEditorDialog : public QDialog
+{
+    Q_OBJECT
+public:
+    explicit TableWidgetEditorDialog(QDesignerFormWindowInterface *form, QWidget *parent);
+
+    TableWidgetContents fillContentsFromTableWidget(QTableWidget *tableWidget);
+    TableWidgetContents contents() const;
+
+private:
+    TableWidgetEditor m_editor;
+};
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // TABLEWIDGETEDITOR_H
diff --git a/src/designer/src/components/taskmenu/tablewidgeteditor.ui b/src/designer/src/components/taskmenu/tablewidgeteditor.ui
new file mode 100644
index 000000000..33691e94d
--- /dev/null
+++ b/src/designer/src/components/taskmenu/tablewidgeteditor.ui
@@ -0,0 +1,157 @@
+<ui version="4.0" >
+ <comment>*********************************************************************
+**
+** 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$
+**
+*********************************************************************</comment>
+ <class>qdesigner_internal::TableWidgetEditor</class>
+ <widget class="QDialog" name="qdesigner_internal::TableWidgetEditor" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>550</width>
+    <height>360</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Edit Table Widget</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout" >
+   <item>
+    <widget class="QTabWidget" name="tabWidget" >
+     <property name="currentIndex" >
+      <number>0</number>
+     </property>
+     <widget class="QWidget" name="itemsTab" >
+      <attribute name="title" >
+       <string>&amp;Items</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_2" >
+       <item>
+        <widget class="QWidget" native="1" name="widget" >
+         <layout class="QVBoxLayout" name="verticalLayout_3" >
+          <property name="margin" >
+           <number>0</number>
+          </property>
+          <item>
+           <widget class="QTableWidget" name="tableWidget" >
+            <property name="toolTip" >
+             <string>Table Items</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" name="buttonsLayout" >
+            <item>
+             <spacer name="horizontalSpacer" >
+              <property name="orientation" >
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0" >
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item>
+             <widget class="QPushButton" name="showPropertiesButton" >
+              <property name="text" >
+               <string>Properties &amp;>></string>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox" >
+     <property name="orientation" >
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons" >
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>qdesigner_internal::TableWidgetEditor</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>431</x>
+     <y>351</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>373</x>
+     <y>362</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>qdesigner_internal::TableWidgetEditor</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>547</x>
+     <y>354</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>562</x>
+     <y>362</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/src/designer/src/components/taskmenu/taskmenu.pri b/src/designer/src/components/taskmenu/taskmenu.pri
new file mode 100644
index 000000000..066b92980
--- /dev/null
+++ b/src/designer/src/components/taskmenu/taskmenu.pri
@@ -0,0 +1,50 @@
+INCLUDEPATH += $$PWD \
+    ../propertyeditor \
+    $$QT_BUILD_TREE/tools/designer/src/components/taskmenu \
+    $$QT_SOURCE_TREE/tools/shared/qtpropertybrowser
+
+FORMS += $$PWD/itemlisteditor.ui \
+    $$PWD/treewidgeteditor.ui \
+    $$PWD/tablewidgeteditor.ui
+
+HEADERS += $$PWD/button_taskmenu.h \
+  $$PWD/groupbox_taskmenu.h \
+  $$PWD/label_taskmenu.h \
+  $$PWD/lineedit_taskmenu.h \
+  $$PWD/listwidget_taskmenu.h \
+  $$PWD/treewidget_taskmenu.h \
+  $$PWD/tablewidget_taskmenu.h \
+  $$PWD/combobox_taskmenu.h \
+  $$PWD/textedit_taskmenu.h \
+  $$PWD/toolbar_taskmenu.h \
+  $$PWD/containerwidget_taskmenu.h \
+  $$PWD/inplace_editor.h \
+  $$PWD/taskmenu_component.h \
+  $$PWD/itemlisteditor.h \
+  $$PWD/listwidgeteditor.h \
+  $$PWD/treewidgeteditor.h \
+  $$PWD/tablewidgeteditor.h \
+  $$PWD/inplace_widget_helper.h \
+  $$PWD/menutaskmenu.h \
+  $$PWD/layouttaskmenu.h
+
+SOURCES += $$PWD/button_taskmenu.cpp \
+  $$PWD/groupbox_taskmenu.cpp \
+  $$PWD/label_taskmenu.cpp \
+  $$PWD/lineedit_taskmenu.cpp \
+  $$PWD/listwidget_taskmenu.cpp \
+  $$PWD/treewidget_taskmenu.cpp \
+  $$PWD/tablewidget_taskmenu.cpp \
+  $$PWD/combobox_taskmenu.cpp \
+  $$PWD/textedit_taskmenu.cpp \
+  $$PWD/toolbar_taskmenu.cpp \
+  $$PWD/containerwidget_taskmenu.cpp \
+  $$PWD/inplace_editor.cpp \
+  $$PWD/taskmenu_component.cpp \
+  $$PWD/itemlisteditor.cpp \
+  $$PWD/listwidgeteditor.cpp \
+  $$PWD/treewidgeteditor.cpp \
+  $$PWD/tablewidgeteditor.cpp \
+  $$PWD/inplace_widget_helper.cpp \
+  $$PWD/menutaskmenu.cpp \
+  $$PWD/layouttaskmenu.cpp
diff --git a/src/designer/src/components/taskmenu/taskmenu_component.cpp b/src/designer/src/components/taskmenu/taskmenu_component.cpp
new file mode 100644
index 000000000..c7f395349
--- /dev/null
+++ b/src/designer/src/components/taskmenu/taskmenu_component.cpp
@@ -0,0 +1,106 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "taskmenu_component.h"
+#include "button_taskmenu.h"
+#include "groupbox_taskmenu.h"
+#include "label_taskmenu.h"
+#include "lineedit_taskmenu.h"
+#include "listwidget_taskmenu.h"
+#include "treewidget_taskmenu.h"
+#include "tablewidget_taskmenu.h"
+#include "containerwidget_taskmenu.h"
+#include "combobox_taskmenu.h"
+#include "textedit_taskmenu.h"
+#include "menutaskmenu.h"
+#include "toolbar_taskmenu.h"
+#include "layouttaskmenu.h"
+
+#include <QtDesigner/QDesignerFormEditorInterface>
+#include <QtDesigner/QExtensionManager>
+
+QT_BEGIN_NAMESPACE
+
+using namespace qdesigner_internal;
+
+TaskMenuComponent::TaskMenuComponent(QDesignerFormEditorInterface *core, QObject *parent)
+    : QObject(parent),
+      m_core(core)
+{
+    Q_ASSERT(m_core != 0);
+
+    QExtensionManager *mgr = core->extensionManager();
+    const QString taskMenuId =  QLatin1String("QDesignerInternalTaskMenuExtension");
+
+    ButtonTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    CommandLinkButtonTaskMenuFactory::registerExtension(mgr, taskMenuId); // Order!
+    ButtonGroupTaskMenuFactory::registerExtension(mgr, taskMenuId);
+
+    GroupBoxTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    LabelTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    LineEditTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    ListWidgetTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    TreeWidgetTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    TableWidgetTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    TextEditTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    PlainTextEditTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    MenuTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    MenuBarTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    ToolBarTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    StatusBarTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    LayoutWidgetTaskMenuFactory::registerExtension(mgr, taskMenuId);
+    SpacerTaskMenuFactory::registerExtension(mgr, taskMenuId);
+
+    mgr->registerExtensions(new ContainerWidgetTaskMenuFactory(core, mgr), taskMenuId);
+    mgr->registerExtensions(new ComboBoxTaskMenuFactory(taskMenuId, mgr), taskMenuId);
+}
+
+TaskMenuComponent::~TaskMenuComponent()
+{
+}
+
+QDesignerFormEditorInterface *TaskMenuComponent::core() const
+{
+    return m_core;
+
+}
+QT_END_NAMESPACE
+
diff --git a/src/designer/src/components/taskmenu/taskmenu_component.h b/src/designer/src/components/taskmenu/taskmenu_component.h
new file mode 100644
index 000000000..762567c84
--- /dev/null
+++ b/src/designer/src/components/taskmenu/taskmenu_component.h
@@ -0,0 +1,73 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TASKMENU_COMPONENT_H
+#define TASKMENU_COMPONENT_H
+
+#include "taskmenu_global.h"
+#include <QtDesigner/taskmenu.h>
+
+#include <QtCore/QObject>
+
+QT_BEGIN_NAMESPACE
+
+class QDesignerFormEditorInterface;
+
+namespace qdesigner_internal {
+
+class QT_TASKMENU_EXPORT TaskMenuComponent: public QObject
+{
+    Q_OBJECT
+public:
+    explicit TaskMenuComponent(QDesignerFormEditorInterface *core, QObject *parent = 0);
+    virtual ~TaskMenuComponent();
+
+    QDesignerFormEditorInterface *core() const;
+
+private:
+    QDesignerFormEditorInterface *m_core;
+};
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // TASKMENU_COMPONENT_H
diff --git a/src/designer/src/components/taskmenu/taskmenu_global.h b/src/designer/src/components/taskmenu/taskmenu_global.h
new file mode 100644
index 000000000..df276016c
--- /dev/null
+++ b/src/designer/src/components/taskmenu/taskmenu_global.h
@@ -0,0 +1,57 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TASKMENU_GLOBAL_H
+#define TASKMENU_GLOBAL_H
+
+#include <QtCore/qglobal.h>
+
+#ifdef Q_OS_WIN
+#ifdef QT_TASKMENU_LIBRARY
+# define QT_TASKMENU_EXPORT
+#else
+# define QT_TASKMENU_EXPORT
+#endif
+#else
+#define QT_TASKMENU_EXPORT
+#endif
+
+#endif // TASKMENU_GLOBAL_H
diff --git a/src/designer/src/components/taskmenu/textedit_taskmenu.cpp b/src/designer/src/components/taskmenu/textedit_taskmenu.cpp
new file mode 100644
index 000000000..510a32f5f
--- /dev/null
+++ b/src/designer/src/components/taskmenu/textedit_taskmenu.cpp
@@ -0,0 +1,105 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "textedit_taskmenu.h"
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QAction>
+#include <QtCore/QEvent>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+TextEditTaskMenu::TextEditTaskMenu(QTextEdit *textEdit, QObject *parent) :
+    QDesignerTaskMenu(textEdit, parent),
+    m_format(Qt::RichText),
+    m_property(QLatin1String("html")),
+    m_windowTitle(tr("Edit HTML")),
+    m_editTextAction(new QAction(tr("Change HTML..."), this))
+{
+    initialize();
+}
+
+TextEditTaskMenu::TextEditTaskMenu(QPlainTextEdit *textEdit, QObject *parent) :
+    QDesignerTaskMenu(textEdit, parent),
+    m_format(Qt::PlainText),
+    m_property(QLatin1String("plainText")),
+    m_windowTitle(tr("Edit Text")),
+    m_editTextAction(new QAction(tr("Change Plain Text..."), this))
+{
+    initialize();
+}
+
+
+void TextEditTaskMenu::initialize()
+{
+    connect(m_editTextAction, SIGNAL(triggered()), this, SLOT(editText()));
+    m_taskActions.append(m_editTextAction);
+
+    QAction *sep = new QAction(this);
+    sep->setSeparator(true);
+    m_taskActions.append(sep);
+}
+
+TextEditTaskMenu::~TextEditTaskMenu()
+{
+}
+
+QAction *TextEditTaskMenu::preferredEditAction() const
+{
+    return m_editTextAction;
+}
+
+QList<QAction*> TextEditTaskMenu::taskActions() const
+{
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+void TextEditTaskMenu::editText()
+{
+    changeTextProperty(m_property, m_windowTitle, MultiSelectionMode, m_format);
+}
+
+}
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/textedit_taskmenu.h b/src/designer/src/components/taskmenu/textedit_taskmenu.h
new file mode 100644
index 000000000..1429f315e
--- /dev/null
+++ b/src/designer/src/components/taskmenu/textedit_taskmenu.h
@@ -0,0 +1,89 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TEXTEDIT_TASKMENU_H
+#define TEXTEDIT_TASKMENU_H
+
+#include <QtGui/QTextEdit>
+#include <QtGui/QPlainTextEdit>
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class TextEditTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit TextEditTaskMenu(QTextEdit *button, QObject *parent = 0);
+    explicit TextEditTaskMenu(QPlainTextEdit *button, QObject *parent = 0);
+
+    virtual ~TextEditTaskMenu();
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void editText();
+
+private:
+    void initialize();
+
+    const Qt::TextFormat m_format;
+    const QString m_property;
+    const QString m_windowTitle;
+
+    mutable QList<QAction*> m_taskActions;
+    QAction *m_editTextAction;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QTextEdit, TextEditTaskMenu> TextEditTaskMenuFactory;
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QPlainTextEdit, TextEditTaskMenu> PlainTextEditTaskMenuFactory;
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // TEXTEDIT_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/toolbar_taskmenu.cpp b/src/designer/src/components/taskmenu/toolbar_taskmenu.cpp
new file mode 100644
index 000000000..8db233ca2
--- /dev/null
+++ b/src/designer/src/components/taskmenu/toolbar_taskmenu.cpp
@@ -0,0 +1,111 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "toolbar_taskmenu.h"
+#include "qdesigner_toolbar_p.h"
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <promotiontaskmenu_p.h>
+#include <qdesigner_command_p.h>
+
+#include <QtGui/QAction>
+#include <QtGui/QUndoStack>
+
+#include <QtCore/QDebug>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+    // ------------ ToolBarTaskMenu
+    ToolBarTaskMenu::ToolBarTaskMenu(QToolBar *tb, QObject *parent) :
+        QObject(parent),
+        m_toolBar(tb)
+    {
+    }
+
+    QAction *ToolBarTaskMenu::preferredEditAction() const
+    {
+        return 0;
+    }
+
+    QList<QAction*> ToolBarTaskMenu::taskActions() const
+    {
+        if (ToolBarEventFilter *ef = ToolBarEventFilter::eventFilterOf(m_toolBar))
+            return ef->contextMenuActions();
+        return QList<QAction*>();
+    }
+
+    // ------------ StatusBarTaskMenu
+    StatusBarTaskMenu::StatusBarTaskMenu(QStatusBar *sb, QObject *parent) :
+        QObject(parent),
+        m_statusBar(sb),
+        m_removeAction(new QAction(tr("Remove"), this)),
+        m_promotionTaskMenu(new PromotionTaskMenu(sb, PromotionTaskMenu::ModeSingleWidget, this))
+    {
+        connect(m_removeAction, SIGNAL(triggered()), this, SLOT(removeStatusBar()));
+    }
+
+    QAction *StatusBarTaskMenu::preferredEditAction() const
+    {
+        return 0;
+    }
+
+    QList<QAction*> StatusBarTaskMenu::taskActions() const
+    {
+        QList<QAction*> rc;
+        rc.push_back(m_removeAction);
+        m_promotionTaskMenu->addActions(PromotionTaskMenu::LeadingSeparator, rc);
+        return rc;
+    }
+
+    void StatusBarTaskMenu::removeStatusBar()
+    {
+        if (QDesignerFormWindowInterface *fw = QDesignerFormWindowInterface::findFormWindow(m_statusBar)) {
+            DeleteStatusBarCommand *cmd = new DeleteStatusBarCommand(fw);
+            cmd->init(m_statusBar);
+            fw->commandHistory()->push(cmd);
+        }
+    }
+}
+
+QT_END_NAMESPACE
+
diff --git a/src/designer/src/components/taskmenu/toolbar_taskmenu.h b/src/designer/src/components/taskmenu/toolbar_taskmenu.h
new file mode 100644
index 000000000..6818e2607
--- /dev/null
+++ b/src/designer/src/components/taskmenu/toolbar_taskmenu.h
@@ -0,0 +1,99 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TOOLBAR_TASKMENU_H
+#define TOOLBAR_TASKMENU_H
+
+#include <QtDesigner/QDesignerTaskMenuExtension>
+
+#include <extensionfactory_p.h>
+
+#include <QtGui/QToolBar>
+#include <QtGui/QStatusBar>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+    class PromotionTaskMenu;
+
+// ToolBarTaskMenu forwards the actions of ToolBarEventFilter
+class ToolBarTaskMenu : public QObject, public QDesignerTaskMenuExtension
+{
+    Q_OBJECT
+    Q_INTERFACES(QDesignerTaskMenuExtension)
+public:
+    explicit ToolBarTaskMenu(QToolBar *tb, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private:
+    QToolBar *m_toolBar;
+};
+
+// StatusBarTaskMenu provides promotion and deletion
+class StatusBarTaskMenu : public QObject, public QDesignerTaskMenuExtension
+{
+    Q_OBJECT
+    Q_INTERFACES(QDesignerTaskMenuExtension)
+public:
+    explicit StatusBarTaskMenu(QStatusBar *tb, QObject *parent = 0);
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void removeStatusBar();
+
+private:
+    QStatusBar  *m_statusBar;
+    QAction *m_removeAction;
+    PromotionTaskMenu *m_promotionTaskMenu;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QToolBar, ToolBarTaskMenu> ToolBarTaskMenuFactory;
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QStatusBar, StatusBarTaskMenu> StatusBarTaskMenuFactory;
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // TOOLBAR_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/treewidget_taskmenu.cpp b/src/designer/src/components/taskmenu/treewidget_taskmenu.cpp
new file mode 100644
index 000000000..96210dcdb
--- /dev/null
+++ b/src/designer/src/components/taskmenu/treewidget_taskmenu.cpp
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "treewidget_taskmenu.h"
+#include "treewidgeteditor.h"
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+
+#include <QtGui/QAction>
+#include <QtGui/QStyle>
+#include <QtGui/QLineEdit>
+#include <QtGui/QStyleOption>
+
+#include <QtCore/QEvent>
+#include <QtCore/QVariant>
+#include <QtCore/qdebug.h>
+
+QT_BEGIN_NAMESPACE
+
+using namespace qdesigner_internal;
+
+TreeWidgetTaskMenu::TreeWidgetTaskMenu(QTreeWidget *button, QObject *parent)
+    : QDesignerTaskMenu(button, parent),
+      m_treeWidget(button),
+      m_editItemsAction(new QAction(tr("Edit Items..."), this))
+{
+    connect(m_editItemsAction, SIGNAL(triggered()), this, SLOT(editItems()));
+    m_taskActions.append(m_editItemsAction);
+
+    QAction *sep = new QAction(this);
+    sep->setSeparator(true);
+    m_taskActions.append(sep);
+}
+
+
+TreeWidgetTaskMenu::~TreeWidgetTaskMenu()
+{
+}
+
+QAction *TreeWidgetTaskMenu::preferredEditAction() const
+{
+    return m_editItemsAction;
+}
+
+QList<QAction*> TreeWidgetTaskMenu::taskActions() const
+{
+    return m_taskActions + QDesignerTaskMenu::taskActions();
+}
+
+void TreeWidgetTaskMenu::editItems()
+{
+    m_formWindow = QDesignerFormWindowInterface::findFormWindow(m_treeWidget);
+    if (m_formWindow.isNull())
+        return;
+
+    Q_ASSERT(m_treeWidget != 0);
+
+    TreeWidgetEditorDialog dlg(m_formWindow, m_treeWidget->window());
+    TreeWidgetContents oldCont = dlg.fillContentsFromTreeWidget(m_treeWidget);
+    if (dlg.exec() == QDialog::Accepted) {
+        TreeWidgetContents newCont = dlg.contents();
+        if (newCont != oldCont) {
+            ChangeTreeContentsCommand *cmd = new ChangeTreeContentsCommand(m_formWindow);
+            cmd->init(m_treeWidget, oldCont, newCont);
+            m_formWindow->commandHistory()->push(cmd);
+        }
+    }
+}
+
+void TreeWidgetTaskMenu::updateSelection()
+{
+    if (m_editor)
+        m_editor->deleteLater();
+}
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/treewidget_taskmenu.h b/src/designer/src/components/taskmenu/treewidget_taskmenu.h
new file mode 100644
index 000000000..e5a9e9073
--- /dev/null
+++ b/src/designer/src/components/taskmenu/treewidget_taskmenu.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TREEWIDGET_TASKMENU_H
+#define TREEWIDGET_TASKMENU_H
+
+#include <QtGui/QTreeWidget>
+#include <QtCore/QPointer>
+
+#include <qdesigner_taskmenu_p.h>
+#include <extensionfactory_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class QLineEdit;
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class TreeWidgetTaskMenu: public QDesignerTaskMenu
+{
+    Q_OBJECT
+public:
+    explicit TreeWidgetTaskMenu(QTreeWidget *button, QObject *parent = 0);
+    virtual ~TreeWidgetTaskMenu();
+
+    virtual QAction *preferredEditAction() const;
+    virtual QList<QAction*> taskActions() const;
+
+private slots:
+    void editItems();
+    void updateSelection();
+
+private:
+    QTreeWidget *m_treeWidget;
+    QPointer<QDesignerFormWindowInterface> m_formWindow;
+    QPointer<QLineEdit> m_editor;
+    mutable QList<QAction*> m_taskActions;
+    QAction *m_editItemsAction;
+};
+
+typedef ExtensionFactory<QDesignerTaskMenuExtension, QTreeWidget, TreeWidgetTaskMenu> TreeWidgetTaskMenuFactory;
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // TREEWIDGET_TASKMENU_H
diff --git a/src/designer/src/components/taskmenu/treewidgeteditor.cpp b/src/designer/src/components/taskmenu/treewidgeteditor.cpp
new file mode 100644
index 000000000..f5f6035f2
--- /dev/null
+++ b/src/designer/src/components/taskmenu/treewidgeteditor.cpp
@@ -0,0 +1,642 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#include "treewidgeteditor.h"
+#include <formwindowbase_p.h>
+#include <iconloader_p.h>
+#include <qdesigner_command_p.h>
+#include <qdesigner_utils_p.h>
+#include <abstractformbuilder.h>
+#include <designerpropertymanager.h>
+#include <qttreepropertybrowser.h>
+
+#include <QtDesigner/QDesignerFormWindowInterface>
+#include <QtDesigner/QDesignerFormEditorInterface>
+#include <QtDesigner/QDesignerIconCacheInterface>
+#include <QtCore/QDir>
+#include <QtCore/QQueue>
+#include <QtGui/QHeaderView>
+#include <QtGui/QTreeWidgetItemIterator>
+
+QT_BEGIN_NAMESPACE
+
+namespace qdesigner_internal {
+
+TreeWidgetEditor::TreeWidgetEditor(QDesignerFormWindowInterface *form, QDialog *dialog)
+    : AbstractItemEditor(form, 0), m_updatingBrowser(false)
+{
+    m_columnEditor = new ItemListEditor(form, this);
+    m_columnEditor->setObjectName(QLatin1String("columnEditor"));
+    m_columnEditor->setNewItemText(tr("New Column"));
+    ui.setupUi(dialog);
+
+    injectPropertyBrowser(ui.itemsTab, ui.widget);
+    connect(ui.showPropertiesButton, SIGNAL(clicked()),
+            this, SLOT(togglePropertyBrowser()));
+    setPropertyBrowserVisible(false);
+
+    ui.tabWidget->insertTab(0, m_columnEditor, tr("&Columns"));
+    ui.tabWidget->setCurrentIndex(0);
+    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+
+    ui.newItemButton->setIcon(createIconSet(QString::fromUtf8("plus.png")));
+    ui.newSubItemButton->setIcon(createIconSet(QString::fromUtf8("downplus.png")));
+    ui.deleteItemButton->setIcon(createIconSet(QString::fromUtf8("minus.png")));
+    ui.moveItemUpButton->setIcon(createIconSet(QString::fromUtf8("up.png")));
+    ui.moveItemDownButton->setIcon(createIconSet(QString::fromUtf8("down.png")));
+    ui.moveItemRightButton->setIcon(createIconSet(QString::fromUtf8("leveldown.png")));
+    ui.moveItemLeftButton->setIcon(createIconSet(QString::fromUtf8("levelup.png")));
+
+    ui.treeWidget->header()->setMovable(false);
+
+    connect(ui.newItemButton, SIGNAL(clicked()), this, SLOT(on_newItemButton_clicked()));
+    connect(ui.newSubItemButton, SIGNAL(clicked()), this, SLOT(on_newSubItemButton_clicked()));
+    connect(ui.moveItemUpButton, SIGNAL(clicked()), this, SLOT(on_moveItemUpButton_clicked()));
+    connect(ui.moveItemDownButton, SIGNAL(clicked()), this, SLOT(on_moveItemDownButton_clicked()));
+    connect(ui.moveItemRightButton, SIGNAL(clicked()), this, SLOT(on_moveItemRightButton_clicked()));
+    connect(ui.moveItemLeftButton, SIGNAL(clicked()), this, SLOT(on_moveItemLeftButton_clicked()));
+    connect(ui.treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
+            this, SLOT(on_treeWidget_currentItemChanged()));
+    connect(ui.treeWidget, SIGNAL(itemChanged(QTreeWidgetItem*,int)),
+            this, SLOT(on_treeWidget_itemChanged(QTreeWidgetItem*,int)));
+
+    connect(m_columnEditor, SIGNAL(indexChanged(int)),
+            this, SLOT(on_columnEditor_indexChanged(int)));
+    connect(m_columnEditor, SIGNAL(itemChanged(int,int,QVariant)),
+            this, SLOT(on_columnEditor_itemChanged(int,int,QVariant)));
+    connect(m_columnEditor, SIGNAL(itemInserted(int)),
+            this, SLOT(on_columnEditor_itemInserted(int)));
+    connect(m_columnEditor, SIGNAL(itemDeleted(int)),
+            this, SLOT(on_columnEditor_itemDeleted(int)));
+    connect(m_columnEditor, SIGNAL(itemMovedUp(int)),
+            this, SLOT(on_columnEditor_itemMovedUp(int)));
+    connect(m_columnEditor, SIGNAL(itemMovedDown(int)),
+            this, SLOT(on_columnEditor_itemMovedDown(int)));
+
+    connect(iconCache(), SIGNAL(reloaded()), this, SLOT(cacheReloaded()));
+}
+
+static AbstractItemEditor::PropertyDefinition treeHeaderPropList[] = {
+    { Qt::DisplayPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "text" },
+    { Qt::DecorationPropertyRole, 0, DesignerPropertyManager::designerIconTypeId, "icon" },
+    { Qt::ToolTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "toolTip" },
+    { Qt::StatusTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "statusTip" },
+    { Qt::WhatsThisPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "whatsThis" },
+    { Qt::FontRole, QVariant::Font, 0, "font" },
+    { Qt::TextAlignmentRole, 0, DesignerPropertyManager::designerAlignmentTypeId, "textAlignment" },
+    { Qt::BackgroundRole, QVariant::Color, 0, "background" },
+    { Qt::ForegroundRole, QVariant::Brush, 0, "foreground" },
+    { 0, 0, 0, 0 }
+};
+
+static AbstractItemEditor::PropertyDefinition treeItemColumnPropList[] = {
+    { Qt::DisplayPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "text" },
+    { Qt::DecorationPropertyRole, 0, DesignerPropertyManager::designerIconTypeId, "icon" },
+    { Qt::ToolTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "toolTip" },
+    { Qt::StatusTipPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "statusTip" },
+    { Qt::WhatsThisPropertyRole, 0, DesignerPropertyManager::designerStringTypeId, "whatsThis" },
+    { Qt::FontRole, QVariant::Font, 0, "font" },
+    { Qt::TextAlignmentRole, 0, DesignerPropertyManager::designerAlignmentTypeId, "textAlignment" },
+    { Qt::BackgroundRole, QVariant::Brush, 0, "background" },
+    { Qt::ForegroundRole, QVariant::Brush, 0, "foreground" },
+    { Qt::CheckStateRole, 0, QtVariantPropertyManager::enumTypeId, "checkState" },
+    { 0, 0, 0, 0 }
+};
+
+static AbstractItemEditor::PropertyDefinition treeItemCommonPropList[] = {
+    { ItemFlagsShadowRole, 0, QtVariantPropertyManager::flagTypeId, "flags" },
+    { 0, 0, 0, 0 }
+};
+
+QtVariantProperty *TreeWidgetEditor::setupPropertyGroup(const QString &title, PropertyDefinition *propDefs)
+{
+    setupProperties(propDefs);
+    QtVariantProperty *groupProp = m_propertyManager->addProperty(QtVariantPropertyManager::groupTypeId(), title);
+    foreach (QtVariantProperty *prop, m_rootProperties)
+        groupProp->addSubProperty(prop);
+    m_rootProperties.clear();
+    return groupProp;
+}
+
+TreeWidgetContents TreeWidgetEditor::fillContentsFromTreeWidget(QTreeWidget *treeWidget)
+{
+    TreeWidgetContents treeCont;
+    treeCont.fromTreeWidget(treeWidget, false);
+    treeCont.applyToTreeWidget(ui.treeWidget, iconCache(), true);
+
+    treeCont.m_headerItem.applyToListWidget(m_columnEditor->listWidget(), iconCache(), true);
+    m_columnEditor->setupEditor(treeWidget, treeHeaderPropList);
+
+    QList<QtVariantProperty*> rootProperties;
+    rootProperties.append(setupPropertyGroup(tr("Per column properties"), treeItemColumnPropList));
+    rootProperties.append(setupPropertyGroup(tr("Common properties"), treeItemCommonPropList));
+    m_rootProperties = rootProperties;
+    m_propertyBrowser->setPropertiesWithoutValueMarked(true);
+    m_propertyBrowser->setRootIsDecorated(false);
+    setupObject(treeWidget);
+
+    if (ui.treeWidget->topLevelItemCount() > 0)
+        ui.treeWidget->setCurrentItem(ui.treeWidget->topLevelItem(0));
+
+    updateEditor();
+
+    return treeCont;
+}
+
+TreeWidgetContents TreeWidgetEditor::contents() const
+{
+    TreeWidgetContents retVal;
+    retVal.fromTreeWidget(ui.treeWidget, true);
+    return retVal;
+}
+
+void TreeWidgetEditor::setItemData(int role, const QVariant &v)
+{
+    const int col = (role == ItemFlagsShadowRole) ? 0 : ui.treeWidget->currentColumn();
+    QVariant newValue = v;
+    BoolBlocker block(m_updatingBrowser);
+    if (role == Qt::FontRole && newValue.type() == QVariant::Font) {
+        QFont oldFont = ui.treeWidget->font();
+        QFont newFont = qvariant_cast<QFont>(newValue).resolve(oldFont);
+        newValue = QVariant::fromValue(newFont);
+        ui.treeWidget->currentItem()->setData(col, role, QVariant()); // force the right font with the current resolve mask is set (item view bug)
+    }
+    ui.treeWidget->currentItem()->setData(col, role, newValue);
+}
+
+QVariant TreeWidgetEditor::getItemData(int role) const
+{
+    const int col = (role == ItemFlagsShadowRole) ? 0 : ui.treeWidget->currentColumn();
+    return ui.treeWidget->currentItem()->data(col, role);
+}
+
+void TreeWidgetEditor::on_newItemButton_clicked()
+{
+    QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
+    QTreeWidgetItem *newItem = 0;
+    ui.treeWidget->blockSignals(true);
+    if (curItem) {
+        if (curItem->parent())
+            newItem = new QTreeWidgetItem(curItem->parent(), curItem);
+        else
+            newItem = new QTreeWidgetItem(ui.treeWidget, curItem);
+    } else
+        newItem = new QTreeWidgetItem(ui.treeWidget);
+    const QString newItemText = tr("New Item");
+    newItem->setText(0, newItemText);
+    newItem->setData(0, Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(newItemText)));
+    newItem->setFlags(newItem->flags() | Qt::ItemIsEditable);
+    ui.treeWidget->blockSignals(false);
+
+    ui.treeWidget->setCurrentItem(newItem, qMax(ui.treeWidget->currentColumn(), 0));
+    updateEditor();
+    ui.treeWidget->editItem(newItem, ui.treeWidget->currentColumn());
+}
+
+void TreeWidgetEditor::on_newSubItemButton_clicked()
+{
+    QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
+    if (!curItem)
+        return;
+
+    ui.treeWidget->blockSignals(true);
+    QTreeWidgetItem *newItem = new QTreeWidgetItem(curItem);
+    const QString newItemText = tr("New Subitem");
+    newItem->setText(0, newItemText);
+    newItem->setData(0, Qt::DisplayPropertyRole, QVariant::fromValue(PropertySheetStringValue(newItemText)));
+    newItem->setFlags(newItem->flags() | Qt::ItemIsEditable);
+    ui.treeWidget->blockSignals(false);
+
+    ui.treeWidget->setCurrentItem(newItem, ui.treeWidget->currentColumn());
+    updateEditor();
+    ui.treeWidget->editItem(newItem, ui.treeWidget->currentColumn());
+}
+
+void TreeWidgetEditor::on_deleteItemButton_clicked()
+{
+    QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
+    if (!curItem)
+        return;
+
+    QTreeWidgetItem *nextCurrent = 0;
+    if (curItem->parent()) {
+        int idx = curItem->parent()->indexOfChild(curItem);
+        if (idx == curItem->parent()->childCount() - 1)
+            idx--;
+        else
+            idx++;
+        if (idx < 0)
+            nextCurrent = curItem->parent();
+        else
+            nextCurrent = curItem->parent()->child(idx);
+    } else {
+        int idx = ui.treeWidget->indexOfTopLevelItem(curItem);
+        if (idx == ui.treeWidget->topLevelItemCount() - 1)
+            idx--;
+        else
+            idx++;
+        if (idx >= 0)
+            nextCurrent = ui.treeWidget->topLevelItem(idx);
+    }
+    closeEditors();
+    ui.treeWidget->blockSignals(true);
+    delete curItem;
+    ui.treeWidget->blockSignals(false);
+
+    if (nextCurrent)
+        ui.treeWidget->setCurrentItem(nextCurrent, ui.treeWidget->currentColumn());
+    updateEditor();
+}
+
+void TreeWidgetEditor::on_moveItemUpButton_clicked()
+{
+    QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
+    if (!curItem)
+        return;
+
+    int idx;
+    if (curItem->parent())
+        idx = curItem->parent()->indexOfChild(curItem);
+    else
+        idx = ui.treeWidget->indexOfTopLevelItem(curItem);
+    if (idx == 0)
+        return;
+
+    QTreeWidgetItem *takenItem;
+    ui.treeWidget->blockSignals(true);
+    if (curItem->parent()) {
+        QTreeWidgetItem *parentItem = curItem->parent();
+        takenItem = parentItem->takeChild(idx);
+        parentItem->insertChild(idx - 1, takenItem);
+    } else {
+        takenItem = ui.treeWidget->takeTopLevelItem(idx);
+        ui.treeWidget->insertTopLevelItem(idx - 1, takenItem);
+    }
+    ui.treeWidget->blockSignals(false);
+
+    ui.treeWidget->setCurrentItem(takenItem, ui.treeWidget->currentColumn());
+    updateEditor();
+}
+
+void TreeWidgetEditor::on_moveItemDownButton_clicked()
+{
+    QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
+    if (!curItem)
+        return;
+
+    int idx, idxCount;
+    if (curItem->parent()) {
+        idx = curItem->parent()->indexOfChild(curItem);
+        idxCount = curItem->parent()->childCount();
+    } else {
+        idx = ui.treeWidget->indexOfTopLevelItem(curItem);
+        idxCount = ui.treeWidget->topLevelItemCount();
+    }
+    if (idx == idxCount - 1)
+        return;
+
+    QTreeWidgetItem *takenItem;
+    ui.treeWidget->blockSignals(true);
+    if (curItem->parent()) {
+        QTreeWidgetItem *parentItem = curItem->parent();
+        takenItem = parentItem->takeChild(idx);
+        parentItem->insertChild(idx + 1, takenItem);
+    } else {
+        takenItem = ui.treeWidget->takeTopLevelItem(idx);
+        ui.treeWidget->insertTopLevelItem(idx + 1, takenItem);
+    }
+    ui.treeWidget->blockSignals(false);
+
+    ui.treeWidget->setCurrentItem(takenItem, ui.treeWidget->currentColumn());
+    updateEditor();
+}
+
+void TreeWidgetEditor::on_moveItemLeftButton_clicked()
+{
+    QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
+    if (!curItem)
+        return;
+
+    QTreeWidgetItem *parentItem = curItem->parent();
+    if (!parentItem)
+        return;
+
+    ui.treeWidget->blockSignals(true);
+    QTreeWidgetItem *takenItem = parentItem->takeChild(parentItem->indexOfChild(curItem));
+    if (parentItem->parent()) {
+        int idx = parentItem->parent()->indexOfChild(parentItem);
+        parentItem->parent()->insertChild(idx, takenItem);
+    } else {
+        int idx = ui.treeWidget->indexOfTopLevelItem(parentItem);
+        ui.treeWidget->insertTopLevelItem(idx, takenItem);
+    }
+    ui.treeWidget->blockSignals(false);
+
+    ui.treeWidget->setCurrentItem(takenItem, ui.treeWidget->currentColumn());
+    updateEditor();
+}
+
+void TreeWidgetEditor::on_moveItemRightButton_clicked()
+{
+    QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
+    if (!curItem)
+        return;
+
+    int idx, idxCount;
+    if (curItem->parent()) {
+        idx = curItem->parent()->indexOfChild(curItem);
+        idxCount = curItem->parent()->childCount();
+    } else {
+        idx = ui.treeWidget->indexOfTopLevelItem(curItem);
+        idxCount = ui.treeWidget->topLevelItemCount();
+    }
+    if (idx == idxCount - 1)
+        return;
+
+    QTreeWidgetItem *takenItem;
+    ui.treeWidget->blockSignals(true);
+    if (curItem->parent()) {
+        QTreeWidgetItem *parentItem = curItem->parent()->child(idx + 1);
+        takenItem = curItem->parent()->takeChild(idx);
+        parentItem->insertChild(0, takenItem);
+    } else {
+        QTreeWidgetItem *parentItem = ui.treeWidget->topLevelItem(idx + 1);
+        takenItem = ui.treeWidget->takeTopLevelItem(idx);
+        parentItem->insertChild(0, takenItem);
+    }
+    ui.treeWidget->blockSignals(false);
+
+    ui.treeWidget->setCurrentItem(takenItem, ui.treeWidget->currentColumn());
+    updateEditor();
+}
+
+void TreeWidgetEditor::togglePropertyBrowser()
+{
+    setPropertyBrowserVisible(!m_propertyBrowser->isVisible());
+}
+
+void TreeWidgetEditor::setPropertyBrowserVisible(bool v)
+{
+    ui.showPropertiesButton->setText(v ? tr("Properties &>>") : tr("Properties &<<"));
+    m_propertyBrowser->setVisible(v);
+}
+
+void TreeWidgetEditor::on_treeWidget_currentItemChanged()
+{
+    m_columnEditor->setCurrentIndex(ui.treeWidget->currentColumn());
+    updateEditor();
+}
+
+void TreeWidgetEditor::on_treeWidget_itemChanged(QTreeWidgetItem *item, int column)
+{
+    if (m_updatingBrowser)
+        return;
+
+    PropertySheetStringValue val = qvariant_cast<PropertySheetStringValue>(item->data(column, Qt::DisplayPropertyRole));
+    val.setValue(item->text(column));
+    BoolBlocker block(m_updatingBrowser);
+    item->setData(column, Qt::DisplayPropertyRole, QVariant::fromValue(val));
+
+    updateBrowser();
+}
+
+void TreeWidgetEditor::on_columnEditor_indexChanged(int idx)
+{
+    if (QTreeWidgetItem *item = ui.treeWidget->currentItem())
+        ui.treeWidget->setCurrentItem(item, idx);
+}
+
+void TreeWidgetEditor::on_columnEditor_itemChanged(int idx, int role, const QVariant &v)
+{
+    if (role == Qt::DisplayPropertyRole)
+        ui.treeWidget->headerItem()->setData(idx, Qt::EditRole, qvariant_cast<PropertySheetStringValue>(v).value());
+    ui.treeWidget->headerItem()->setData(idx, role, v);
+}
+
+void TreeWidgetEditor::updateEditor()
+{
+    QTreeWidgetItem *current = ui.treeWidget->currentItem();
+
+    bool itemsEnabled = false;
+    bool currentItemEnabled = false;
+    bool moveItemUpEnabled = false;
+    bool moveItemDownEnabled = false;
+    bool moveItemRightEnabled = false;
+    bool moveItemLeftEnabled = false;
+
+    if (ui.treeWidget->columnCount() > 0) {
+        itemsEnabled = true;
+        if (current) {
+            int idx;
+            int idxCount;
+            currentItemEnabled = true;
+            if (current->parent()) {
+                moveItemLeftEnabled = true;
+                idx = current->parent()->indexOfChild(current);
+                idxCount = current->parent()->childCount();
+            } else {
+                idx = ui.treeWidget->indexOfTopLevelItem(current);
+                idxCount = ui.treeWidget->topLevelItemCount();
+            }
+            if (idx > 0)
+                moveItemUpEnabled = true;
+            if (idx < idxCount - 1) {
+                moveItemDownEnabled = true;
+                moveItemRightEnabled = true;
+            }
+        }
+    }
+    ui.tabWidget->setTabEnabled(1, itemsEnabled);
+    ui.newSubItemButton->setEnabled(currentItemEnabled);
+    ui.deleteItemButton->setEnabled(currentItemEnabled);
+
+    ui.moveItemUpButton->setEnabled(moveItemUpEnabled);
+    ui.moveItemDownButton->setEnabled(moveItemDownEnabled);
+    ui.moveItemRightButton->setEnabled(moveItemRightEnabled);
+    ui.moveItemLeftButton->setEnabled(moveItemLeftEnabled);
+
+    if (current)
+        updateBrowser();
+    else
+        m_propertyBrowser->clear();
+}
+
+void TreeWidgetEditor::moveColumnItems(const PropertyDefinition *propList,
+        QTreeWidgetItem *item, int fromColumn, int toColumn, int step)
+{
+    BoolBlocker block(m_updatingBrowser);
+
+    QList<QVariant> saveCol;
+    for (int j = 0; propList[j].name; j++)
+        saveCol.append(item->data(toColumn, propList[j].role));
+    QVariant editVariant = item->data(toColumn, Qt::EditRole);
+    QVariant toolTipVariant = item->data(toColumn, Qt::ToolTipRole);
+    QVariant statusTipVariant = item->data(toColumn, Qt::StatusTipRole);
+    QVariant whatsThisVariant = item->data(toColumn, Qt::WhatsThisRole);
+    QVariant decorationVariant = item->data(toColumn, Qt::DecorationRole);
+    for (int i = toColumn; i != fromColumn; i += step) {
+        for (int j = 0; propList[j].name; j++)
+            item->setData(i, propList[j].role, item->data(i + step, propList[j].role));
+        item->setData(i, Qt::EditRole, item->data(i + step, Qt::EditRole));
+        item->setData(i, Qt::ToolTipRole, item->data(i + step, Qt::ToolTipRole));
+        item->setData(i, Qt::StatusTipRole, item->data(i + step, Qt::StatusTipRole));
+        item->setData(i, Qt::WhatsThisRole, item->data(i + step, Qt::WhatsThisRole));
+        item->setData(i, Qt::DecorationRole, item->data(i + step, Qt::DecorationRole));
+    }
+    for (int j = 0; propList[j].name; j++)
+        item->setData(fromColumn, propList[j].role, saveCol[j]);
+    item->setData(fromColumn, Qt::EditRole, editVariant);
+    item->setData(fromColumn, Qt::ToolTipRole, toolTipVariant);
+    item->setData(fromColumn, Qt::StatusTipRole, statusTipVariant);
+    item->setData(fromColumn, Qt::WhatsThisRole, whatsThisVariant);
+    item->setData(fromColumn, Qt::DecorationRole, decorationVariant);
+}
+
+void TreeWidgetEditor::moveColumns(int fromColumn, int toColumn, int step)
+{
+    ui.treeWidget->blockSignals(true);
+
+    moveColumnItems(treeHeaderPropList, ui.treeWidget->headerItem(), fromColumn, toColumn, step);
+
+    QQueue<QTreeWidgetItem *> pendingQueue;
+    for (int i = 0; i < ui.treeWidget->topLevelItemCount(); i++)
+        pendingQueue.enqueue(ui.treeWidget->topLevelItem(i));
+
+    while (!pendingQueue.isEmpty()) {
+        QTreeWidgetItem *item = pendingQueue.dequeue();
+        for (int i = 0; i < item->childCount(); i++)
+            pendingQueue.enqueue(item->child(i));
+
+        moveColumnItems(treeItemColumnPropList, item, fromColumn, toColumn, step);
+    }
+
+    ui.treeWidget->blockSignals(false);
+}
+
+void TreeWidgetEditor::moveColumnsLeft(int fromColumn, int toColumn)
+{
+    if (fromColumn >= toColumn)
+        return;
+
+    moveColumns(fromColumn, toColumn, -1);
+}
+
+void TreeWidgetEditor::moveColumnsRight(int fromColumn, int toColumn)
+{
+    if (fromColumn >= toColumn)
+        return;
+
+    moveColumns(toColumn, fromColumn, 1);
+}
+
+void TreeWidgetEditor::on_columnEditor_itemInserted(int idx)
+{
+    int columnCount = ui.treeWidget->columnCount();
+    ui.treeWidget->setColumnCount(columnCount + 1);
+    ui.treeWidget->headerItem()->setText(columnCount, m_columnEditor->newItemText());
+    moveColumnsLeft(idx, columnCount);
+
+    updateEditor();
+}
+
+void TreeWidgetEditor::on_columnEditor_itemDeleted(int idx)
+{
+    closeEditors();
+
+    int columnCount = ui.treeWidget->columnCount() - 1;
+    if (!columnCount)
+        ui.treeWidget->clear();
+    else
+        moveColumnsRight(idx, columnCount);
+    ui.treeWidget->setColumnCount(columnCount);
+
+    updateEditor();
+}
+
+void TreeWidgetEditor::on_columnEditor_itemMovedUp(int idx)
+{
+    moveColumnsRight(idx - 1, idx);
+
+    ui.treeWidget->setCurrentItem(ui.treeWidget->currentItem(), idx - 1);
+    updateEditor();
+}
+
+void TreeWidgetEditor::on_columnEditor_itemMovedDown(int idx)
+{
+    moveColumnsLeft(idx, idx + 1);
+
+    ui.treeWidget->setCurrentItem(ui.treeWidget->currentItem(), idx + 1);
+    updateEditor();
+}
+
+void TreeWidgetEditor::closeEditors()
+{
+    if (QTreeWidgetItem *cur = ui.treeWidget->currentItem() ) {
+        const int numCols = cur->columnCount ();
+        for (int i = 0; i < numCols; i++)
+            ui.treeWidget->closePersistentEditor (cur, i);
+    }
+}
+
+void TreeWidgetEditor::cacheReloaded()
+{
+    reloadIconResources(iconCache(), ui.treeWidget);
+}
+
+TreeWidgetEditorDialog::TreeWidgetEditorDialog(QDesignerFormWindowInterface *form, QWidget *parent) :
+    QDialog(parent), m_editor(form, this)
+{
+    setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+}
+
+TreeWidgetContents TreeWidgetEditorDialog::fillContentsFromTreeWidget(QTreeWidget *treeWidget)
+{
+    return m_editor.fillContentsFromTreeWidget(treeWidget);
+}
+
+TreeWidgetContents TreeWidgetEditorDialog::contents() const
+{
+    return m_editor.contents();
+}
+
+} // namespace qdesigner_internal
+
+QT_END_NAMESPACE
diff --git a/src/designer/src/components/taskmenu/treewidgeteditor.h b/src/designer/src/components/taskmenu/treewidgeteditor.h
new file mode 100644
index 000000000..f502bf3e4
--- /dev/null
+++ b/src/designer/src/components/taskmenu/treewidgeteditor.h
@@ -0,0 +1,129 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+#ifndef TREEWIDGETEDITOR_H
+#define TREEWIDGETEDITOR_H
+
+#include "ui_treewidgeteditor.h"
+
+#include "listwidgeteditor.h"
+
+#include <QtGui/QDialog>
+
+QT_BEGIN_NAMESPACE
+
+class QTreeWidget;
+class QDesignerFormWindowInterface;
+
+namespace qdesigner_internal {
+
+class FormWindowBase;
+class PropertySheetIconValue;
+
+class TreeWidgetEditor: public AbstractItemEditor
+{
+    Q_OBJECT
+public:
+    explicit TreeWidgetEditor(QDesignerFormWindowInterface *form, QDialog *dialog);
+
+    TreeWidgetContents fillContentsFromTreeWidget(QTreeWidget *treeWidget);
+    TreeWidgetContents contents() const;
+
+private slots:
+    void on_newItemButton_clicked();
+    void on_newSubItemButton_clicked();
+    void on_deleteItemButton_clicked();
+    void on_moveItemUpButton_clicked();
+    void on_moveItemDownButton_clicked();
+    void on_moveItemRightButton_clicked();
+    void on_moveItemLeftButton_clicked();
+
+    void on_treeWidget_currentItemChanged();
+    void on_treeWidget_itemChanged(QTreeWidgetItem *item, int column);
+
+    void on_columnEditor_indexChanged(int idx);
+    void on_columnEditor_itemChanged(int idx, int role, const QVariant &v);
+
+    void on_columnEditor_itemInserted(int idx);
+    void on_columnEditor_itemDeleted(int idx);
+    void on_columnEditor_itemMovedUp(int idx);
+    void on_columnEditor_itemMovedDown(int idx);
+
+    void togglePropertyBrowser();
+    void cacheReloaded();
+
+protected:
+    virtual void setItemData(int role, const QVariant &v);
+    virtual QVariant getItemData(int role) const;
+
+private:
+    void setPropertyBrowserVisible(bool v);
+    QtVariantProperty *setupPropertyGroup(const QString &title, PropertyDefinition *propDefs);
+    void updateEditor();
+    void moveColumnItems(const PropertyDefinition *propList, QTreeWidgetItem *item, int fromColumn, int toColumn, int step);
+    void moveColumns(int fromColumn, int toColumn, int step);
+    void moveColumnsLeft(int fromColumn, int toColumn);
+    void moveColumnsRight(int fromColumn, int toColumn);
+    void closeEditors();
+
+    Ui::TreeWidgetEditor ui;
+    ItemListEditor *m_columnEditor;
+    bool m_updatingBrowser;
+};
+
+class TreeWidgetEditorDialog : public QDialog
+{
+    Q_OBJECT
+public:
+    explicit TreeWidgetEditorDialog(QDesignerFormWindowInterface *form, QWidget *parent);
+
+    TreeWidgetContents fillContentsFromTreeWidget(QTreeWidget *treeWidget);
+    TreeWidgetContents contents() const;
+
+private:
+    TreeWidgetEditor m_editor;
+};
+
+}  // namespace qdesigner_internal
+
+QT_END_NAMESPACE
+
+#endif // TREEWIDGETEDITOR_H
diff --git a/src/designer/src/components/taskmenu/treewidgeteditor.ui b/src/designer/src/components/taskmenu/treewidgeteditor.ui
new file mode 100644
index 000000000..7a71d4404
--- /dev/null
+++ b/src/designer/src/components/taskmenu/treewidgeteditor.ui
@@ -0,0 +1,257 @@
+<ui version="4.0" >
+ <comment>*********************************************************************
+**
+** 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$
+**
+*********************************************************************</comment>
+ <class>qdesigner_internal::TreeWidgetEditor</class>
+ <widget class="QDialog" name="qdesigner_internal::TreeWidgetEditor" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>700</width>
+    <height>360</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>Edit Tree Widget</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout" >
+   <item>
+    <widget class="QTabWidget" name="tabWidget" >
+     <property name="currentIndex" >
+      <number>0</number>
+     </property>
+     <widget class="QWidget" name="itemsTab" >
+      <attribute name="title" >
+       <string>&amp;Items</string>
+      </attribute>
+      <layout class="QVBoxLayout" name="verticalLayout_3" >
+       <property name="leftMargin" >
+        <number>9</number>
+       </property>
+       <property name="topMargin" >
+        <number>9</number>
+       </property>
+       <property name="rightMargin" >
+        <number>9</number>
+       </property>
+       <item>
+        <widget class="QWidget" native="1" name="widget" >
+         <layout class="QVBoxLayout" name="verticalLayout_2" >
+          <property name="margin" >
+           <number>0</number>
+          </property>
+          <item>
+           <widget class="QTreeWidget" name="treeWidget" >
+            <property name="focusPolicy" >
+             <enum>Qt::WheelFocus</enum>
+            </property>
+            <property name="toolTip" >
+             <string>Tree Items</string>
+            </property>
+            <column>
+             <property name="text" >
+              <string>1</string>
+             </property>
+            </column>
+           </widget>
+          </item>
+          <item>
+           <layout class="QHBoxLayout" name="buttonsLayout" >
+            <item>
+             <widget class="QToolButton" name="newItemButton" >
+              <property name="toolTip" >
+               <string>New Item</string>
+              </property>
+              <property name="text" >
+               <string>&amp;New</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QToolButton" name="newSubItemButton" >
+              <property name="toolTip" >
+               <string>New Subitem</string>
+              </property>
+              <property name="text" >
+               <string>New &amp;Subitem</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QToolButton" name="deleteItemButton" >
+              <property name="toolTip" >
+               <string>Delete Item</string>
+              </property>
+              <property name="text" >
+               <string>&amp;Delete</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <spacer>
+              <property name="orientation" >
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0" >
+               <size>
+                <width>28</width>
+                <height>23</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item>
+             <widget class="QToolButton" name="moveItemLeftButton" >
+              <property name="toolTip" >
+               <string>Move Item Left (before Parent Item)</string>
+              </property>
+              <property name="text" >
+               <string>L</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QToolButton" name="moveItemRightButton" >
+              <property name="toolTip" >
+               <string>Move Item Right (as a First Subitem of the Next Sibling Item)</string>
+              </property>
+              <property name="text" >
+               <string>R</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QToolButton" name="moveItemUpButton" >
+              <property name="toolTip" >
+               <string>Move Item Up</string>
+              </property>
+              <property name="text" >
+               <string>U</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QToolButton" name="moveItemDownButton" >
+              <property name="toolTip" >
+               <string>Move Item Down</string>
+              </property>
+              <property name="text" >
+               <string>D</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <spacer name="horizontalSpacer" >
+              <property name="orientation" >
+               <enum>Qt::Horizontal</enum>
+              </property>
+              <property name="sizeHint" stdset="0" >
+               <size>
+                <width>40</width>
+                <height>20</height>
+               </size>
+              </property>
+             </spacer>
+            </item>
+            <item>
+             <widget class="QPushButton" name="showPropertiesButton" >
+              <property name="text" >
+               <string>Properties &amp;>></string>
+              </property>
+             </widget>
+            </item>
+           </layout>
+          </item>
+         </layout>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+    </widget>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox" >
+     <property name="orientation" >
+      <enum>Qt::Horizontal</enum>
+     </property>
+     <property name="standardButtons" >
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>qdesigner_internal::TreeWidgetEditor</receiver>
+   <slot>accept()</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>440</x>
+     <y>335</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>373</x>
+     <y>362</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>qdesigner_internal::TreeWidgetEditor</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel" >
+     <x>556</x>
+     <y>335</y>
+    </hint>
+    <hint type="destinationlabel" >
+     <x>562</x>
+     <y>362</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>