/****************************************************************************

**

** Copyright (C) 2009 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 "widgetboxtreewidget.h"

#include "widgetboxcategorylistview.h"

// shared

#include <iconloader_p.h>

#include <sheet_delegate_p.h>

#include <QtDesigner/private/abstractsettings_p.h>

#include <ui4_p.h>

#include <qdesigner_utils_p.h>

#include <pluginmanager_p.h>

// sdk

#include <QtDesigner/QDesignerFormEditorInterface>

#include <QtDesigner/QDesignerDnDItemInterface>

#include <QtDesigner/QDesignerCustomWidgetInterface>

#include <QtDesigner/private/abstractsettings_p.h>

#include <QtGui/QHeaderView>

#include <QtGui/QApplication>

#include <QtGui/QTreeWidgetItem>

#include <QtGui/QContextMenuEvent>

#include <QtGui/QAction>

#include <QtGui/QActionGroup>

#include <QtGui/QMenu>

#include <QtCore/QFile>

#include <QtCore/QTimer>

#include <QtCore/QDebug>

static const char *widgetBoxRootElementC = "widgetbox";

static const char *widgetElementC = "widget";

static const char *uiElementC = "ui";

static const char *categoryElementC = "category";

static const char *categoryEntryElementC = "categoryentry";

static const char *nameAttributeC = "name";

static const char *typeAttributeC = "type";

static const char *iconAttributeC = "icon";

static const char *defaultTypeValueC = "default";

static const char *customValueC = "custom";

static const char *iconPrefixC = "__qt_icon__";

static const char *scratchPadValueC = "scratchpad";

static const char *qtLogoC = "qtlogo.png";

static const char *invisibleNameC = "[invisible]";

enum TopLevelRole  { NORMAL_ITEM, SCRATCHPAD_ITEM, CUSTOM_ITEM };

QT_BEGIN_NAMESPACE

static void setTopLevelRole(TopLevelRole tlr, QTreeWidgetItem *item)

{

    item->setData(0, Qt::UserRole, QVariant(tlr));

}

static TopLevelRole topLevelRole(const  QTreeWidgetItem *item)

{

    return static_cast<TopLevelRole>(item->data(0, Qt::UserRole).toInt());

}

namespace qdesigner_internal {

WidgetBoxTreeWidget::WidgetBoxTreeWidget(QDesignerFormEditorInterface *core, QWidget *parent) :

    QTreeWidget(parent),

    m_core(core),

    m_iconMode(false),

    m_scratchPadDeleteTimer(0)

{

    setFocusPolicy(Qt::NoFocus);

    setIndentation(0);

    setRootIsDecorated(false);

    setColumnCount(1);

    header()->hide();

    header()->setResizeMode(QHeaderView::Stretch);

    setTextElideMode(Qt::ElideMiddle);

    setVerticalScrollMode(ScrollPerPixel);

    setItemDelegate(new SheetDelegate(this, this));

    connect(this, SIGNAL(itemPressed(QTreeWidgetItem*,int)),

            this, SLOT(handleMousePress(QTreeWidgetItem*)));

}

QIcon WidgetBoxTreeWidget::iconForWidget(QString iconName) const

{

    if (iconName.isEmpty())

        iconName = QLatin1String(qtLogoC);

    if (iconName.startsWith(QLatin1String(iconPrefixC))) {

        const IconCache::const_iterator it = m_pluginIcons.constFind(iconName);

        if (it != m_pluginIcons.constEnd())

            return it.value();

    }

    return createIconSet(iconName);

}

WidgetBoxCategoryListView *WidgetBoxTreeWidget::categoryViewAt(int idx) const

{

    WidgetBoxCategoryListView *rc = 0;

    if (QTreeWidgetItem *cat_item = topLevelItem(idx))

        if (QTreeWidgetItem *embedItem = cat_item->child(0))

            rc = qobject_cast<WidgetBoxCategoryListView*>(itemWidget(embedItem, 0));

    Q_ASSERT(rc);

    return rc;

}

void WidgetBoxTreeWidget::saveExpandedState() const

{

    QStringList closedCategories;

    if (const int numCategories = categoryCount()) {

        for (int i = 0; i < numCategories; ++i) {

            const QTreeWidgetItem *cat_item = topLevelItem(i);

            if (!isItemExpanded(cat_item))

                closedCategories.append(cat_item->text(0));

        }

    }

    QDesignerSettingsInterface *settings = m_core->settingsManager();

    settings->beginGroup(QLatin1String(widgetBoxRootElementC));

    settings->setValue(QLatin1String("Closed categories"), closedCategories);

    settings->setValue(QLatin1String("View mode"), m_iconMode);

    settings->endGroup();

}

void  WidgetBoxTreeWidget::restoreExpandedState()

{

    typedef QSet<QString> StringSet;

    QDesignerSettingsInterface *settings = m_core->settingsManager();

    m_iconMode = settings->value(QLatin1String("WidgetBox/View mode")).toBool();

    updateViewMode();

    const StringSet closedCategories = settings->value(QLatin1String("WidgetBox/Closed categories"), QStringList()).toStringList().toSet();

    expandAll();

    if (closedCategories.empty())

        return;

    if (const int numCategories = categoryCount()) {

        for (int i = 0; i < numCategories; ++i) {

            QTreeWidgetItem *item = topLevelItem(i);

            if (closedCategories.contains(item->text(0)))

                item->setExpanded(false);

            }

    }

}

WidgetBoxTreeWidget::~WidgetBoxTreeWidget()

{

    saveExpandedState();

}

void WidgetBoxTreeWidget::setFileName(const QString &file_name)

{

    m_file_name = file_name;

}

QString WidgetBoxTreeWidget::fileName() const

{

    return m_file_name;

}

bool WidgetBoxTreeWidget::save()

{

    if (fileName().isEmpty())

        return false;

    QFile file(fileName());

    if (!file.open(QIODevice::WriteOnly))

        return false;

    CategoryList cat_list;

    const int count = categoryCount();

    for (int i = 0; i < count; ++i)

        cat_list.append(category(i));

    QXmlStreamWriter writer(&file);

    writer.setAutoFormatting(true);

    writer.setAutoFormattingIndent(1);

    writer.writeStartDocument();

    writeCategories(writer, cat_list);

    writer.writeEndDocument();

    return true;

}

void WidgetBoxTreeWidget::slotSave()

{

    save();

}

void WidgetBoxTreeWidget::handleMousePress(QTreeWidgetItem *item)

{

    if (item == 0)

        return;

    if (QApplication::mouseButtons() != Qt::LeftButton)

        return;

    if (item->parent() == 0) {

        setItemExpanded(item, !isItemExpanded(item));

        return;

    }

}

int WidgetBoxTreeWidget::ensureScratchpad()

{

    const int existingIndex = indexOfScratchpad();

    if (existingIndex != -1)

         return existingIndex;

    QTreeWidgetItem *scratch_item = new QTreeWidgetItem(this);

    scratch_item->setText(0, tr("Scratchpad"));

    setTopLevelRole(SCRATCHPAD_ITEM, scratch_item);

    addCategoryView(scratch_item, false); // Scratchpad in list mode.

    return categoryCount() - 1;

}

WidgetBoxCategoryListView *WidgetBoxTreeWidget::addCategoryView(QTreeWidgetItem *parent, bool iconMode)

{

    QTreeWidgetItem *embed_item = new QTreeWidgetItem(parent);

    embed_item->setFlags(Qt::ItemIsEnabled);

    WidgetBoxCategoryListView *categoryView = new WidgetBoxCategoryListView(m_core, this);

    categoryView->setViewMode(iconMode ? QListView::IconMode : QListView::ListMode);

    connect(categoryView, SIGNAL(scratchPadChanged()), this, SLOT(slotSave()));

    connect(categoryView, SIGNAL(pressed(QString,QString,QPoint)), this, SIGNAL(pressed(QString,QString,QPoint)));

    connect(categoryView, SIGNAL(itemRemoved()), this, SLOT(slotScratchPadItemDeleted()));

    connect(categoryView, SIGNAL(lastItemRemoved()), this, SLOT(slotLastScratchPadItemDeleted()));

    setItemWidget(embed_item, 0, categoryView);

    return categoryView;

}

int WidgetBoxTreeWidget::indexOfScratchpad() const

{

    if (const int numTopLevels =  topLevelItemCount()) {

        for (int i = numTopLevels - 1; i >= 0; --i) {

            if (topLevelRole(topLevelItem(i)) == SCRATCHPAD_ITEM)

                return i;

        }

    }

    return -1;

}

int WidgetBoxTreeWidget::indexOfCategory(const QString &name) const

{

    const int topLevelCount = topLevelItemCount();

    for (int i = 0; i < topLevelCount; ++i) {

        if (topLevelItem(i)->text(0) == name)

            return i;

    }

    return -1;

}

bool WidgetBoxTreeWidget::load(QDesignerWidgetBox::LoadMode loadMode)

{

    switch (loadMode) {

    case QDesignerWidgetBox::LoadReplace:

        clear();

        break;

    case QDesignerWidgetBox::LoadCustomWidgetsOnly:

        addCustomCategories(true);

        updateGeometries();

        return true;

    default:

        break;

    }

    const QString name = fileName();

    QFile f(name);

    if (!f.open(QIODevice::ReadOnly)) // Might not exist at first startup

        return false;

    const QString contents = QString::fromUtf8(f.readAll());

    return loadContents(contents);

}

bool WidgetBoxTreeWidget::loadContents(const QString &contents)

{

    QString errorMessage;

    CategoryList cat_list;

    if (!readCategories(m_file_name, contents, &cat_list, &errorMessage)) {

        qdesigner_internal::designerWarning(errorMessage);

        return false;

    }

    foreach(const Category &cat, cat_list)

        addCategory(cat);

    addCustomCategories(false);

    // Restore which items are expanded

    restoreExpandedState();

    return true;

}

void WidgetBoxTreeWidget::addCustomCategories(bool replace)

{

    if (replace) {

        // clear out all existing custom widgets

        if (const int numTopLevels =  topLevelItemCount()) {

            for (int t = 0; t < numTopLevels ; ++t)

                categoryViewAt(t)->removeCustomWidgets();

        }

    }

    // re-add

    const CategoryList customList = loadCustomCategoryList();

    const CategoryList::const_iterator cend = customList.constEnd();

    for (CategoryList::const_iterator it = customList.constBegin(); it != cend; ++it)

        addCategory(*it);

}

static inline QString msgXmlError(const QString &fileName, const QXmlStreamReader &r)

{

    return QDesignerWidgetBox::tr("An error has been encountered at line %1 of %2: %3")

            .arg(r.lineNumber()).arg(fileName, r.errorString());

}

bool WidgetBoxTreeWidget::readCategories(const QString &fileName, const QString &contents,

                                       CategoryList *cats, QString *errorMessage)

{

    // Read widget box XML:

    //

    //<widgetbox version="4.5">

    // <category name="Layouts">

    //  <categoryentry name="Vertical Layout" icon="win/editvlayout.png" type="default">

    //   <widget class="QListWidget" ...>

    // ...

    QXmlStreamReader reader(contents);

    // Entries of category with name="invisible" should be ignored

    bool ignoreEntries = false;

    while (!reader.atEnd()) {

        switch (reader.readNext()) {

        case QXmlStreamReader::StartElement: {

            const QStringRef tag = reader.name();

            if (tag == QLatin1String(widgetBoxRootElementC)) {

                //<widgetbox version="4.5">

                continue;

            }

            if (tag == QLatin1String(categoryElementC)) {

                // <category name="Layouts">

                const QXmlStreamAttributes attributes = reader.attributes();

                const QString categoryName = attributes.value(QLatin1String(nameAttributeC)).toString();

                if (categoryName == QLatin1String(invisibleNameC)) {

                    ignoreEntries = true;

                } else {

                    Category category(categoryName);

                    if (attributes.value(QLatin1String(typeAttributeC)) == QLatin1String(scratchPadValueC))

                        category.setType(Category::Scratchpad);

                    cats->push_back(category);

                }

                continue;

            }

            if (tag == QLatin1String(categoryEntryElementC)) {

                //  <categoryentry name="Vertical Layout" icon="win/editvlayout.png" type="default">

                if (!ignoreEntries) {

                    QXmlStreamAttributes attr = reader.attributes();

                    const QString widgetName = attr.value(QLatin1String(nameAttributeC)).toString();

                    const QString widgetIcon = attr.value(QLatin1String(iconAttributeC)).toString();

                    const WidgetBoxTreeWidget::Widget::Type widgetType =

                        attr.value(QLatin1String(typeAttributeC)).toString()

                            == QLatin1String(customValueC) ?

                        WidgetBoxTreeWidget::Widget::Custom :

                        WidgetBoxTreeWidget::Widget::Default;

                    Widget w;

                    w.setName(widgetName);

                    w.setIconName(widgetIcon);

                    w.setType(widgetType);

                    if (!readWidget(&w, contents, reader))

                        continue;

                    cats->back().addWidget(w);

                } // ignoreEntries

                continue;

            }

            break;

        }

        case QXmlStreamReader::EndElement: {

           const QStringRef tag = reader.name();

           if (tag == QLatin1String(widgetBoxRootElementC)) {

               continue;

           }

           if (tag == QLatin1String(categoryElementC)) {

               ignoreEntries = false;

               continue;

           }

           if (tag == QLatin1String(categoryEntryElementC)) {

               continue;

           }

           break;

        }

        default: break;

        }

    }

    if (reader.hasError()) {

        *errorMessage = msgXmlError(fileName, reader);

        return false;

    }

    return true;

}

/*!

 * Read out a widget within a category. This can either be

 * enclosed in a <ui> element or a (legacy) <widget> element which may

 * contain nested <widget> elements.

 *

 * Examples:

 *

 * <ui language="c++">

 *  <widget class="MultiPageWidget" name="multipagewidget"> ... </widget>

 *  <customwidgets>...</customwidgets>

 * <ui>

 *

 * or

 *

 * <widget>

 *   <widget> ... </widget>

 *   ...

 * <widget>

 *

 * Returns true on success, false if end was reached or an error has been encountered

 * in which case the reader has its error flag set. If successful, the current item

 * of the reader will be the closing element (</ui> or </widget>)

 */

bool WidgetBoxTreeWidget::readWidget(Widget *w, const QString &xml, QXmlStreamReader &r)

{

    qint64 startTagPosition =0, endTagPosition = 0;

    int nesting = 0;

    bool endEncountered = false;

    bool parsedWidgetTag = false;

    QString outmostElement;

    while (!endEncountered) {

        const qint64 currentPosition = r.characterOffset();

        switch(r.readNext()) {

        case QXmlStreamReader::StartElement:

            if (nesting++ == 0) {

                // First element must be <ui> or (legacy) <widget>

                const QStringRef name = r.name();

                if (name == QLatin1String(uiElementC)) {

                    startTagPosition = currentPosition;

                } else {

                    if (name == QLatin1String(widgetElementC)) {

                        startTagPosition = currentPosition;

                        parsedWidgetTag = true;

                    } else {

                        r.raiseError(QDesignerWidgetBox::tr("Unexpected element <%1> encountered when parsing for <widget> or <ui>").arg(name.toString()));

                        return false;

                    }

                }

            } else {

                // We are within <ui> looking for the first <widget> tag

                if (!parsedWidgetTag && r.name() == QLatin1String(widgetElementC)) {

                    parsedWidgetTag = true;

                }

            }

            break;

        case QXmlStreamReader::EndElement:

            // Reached end of widget?

            if (--nesting == 0)  {

                endTagPosition = r.characterOffset();

                endEncountered = true;

            }

            break;

        case QXmlStreamReader::EndDocument:

            r.raiseError(QDesignerWidgetBox::tr("Unexpected end of file encountered when parsing widgets."));

            return false;

        case QXmlStreamReader::Invalid:

            return false;

        default:

            break;

        }

    }

    if (!parsedWidgetTag) {

        r.raiseError(QDesignerWidgetBox::tr("A widget element could not be found."));

        return false;

    }

    // Oddity: Startposition is 1 off

    QString widgetXml = xml.mid(startTagPosition, endTagPosition - startTagPosition);

    const QChar lessThan = QLatin1Char('<');

    if (!widgetXml.startsWith(lessThan))

        widgetXml.prepend(lessThan);

    w->setDomXml(widgetXml);

    return true;

}

void WidgetBoxTreeWidget::writeCategories(QXmlStreamWriter &writer, const CategoryList &cat_list) const