widgetbox.cpp

来自「奇趣公司比较新的qt/emd版本」· C++ 代码 · 共 1,171 行 · 第 1/3 页

}

void WidgetBoxTreeView::setFileName(const QString &file_name)
{
    m_file_name = file_name;
}

QString WidgetBoxTreeView::fileName() const
{
    return m_file_name;
}

bool WidgetBoxTreeView::save()
{
    if (fileName().isEmpty())
        return false;

    QFile file(fileName());
    if (!file.open(QIODevice::WriteOnly))
        return false;

    CategoryList cat_list;
    for (int i = 0; i < categoryCount(); ++i)
        cat_list.append(category(i));

    const QDomDocument doc = categoryListToDom(cat_list);
    QTextStream stream(&file);
    doc.save(stream, 4);

    return true;
}

void WidgetBoxTreeView::handleMousePress(QTreeWidgetItem *item)
{
    if (item == 0)
        return;

    if (item->parent() == 0) {
        setItemExpanded(item, !isItemExpanded(item));
        return;
    }

    QDesignerWidgetBoxInterface::Widget wgt = itemToWidget(item);
    if (wgt.isNull())
        return;

    emit pressed(wgt.name(), widgetDomXml(wgt), wgt.type() == QDesignerWidgetBoxInterface::Widget::Custom, QCursor::pos());
}

int WidgetBoxTreeView::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);
    return categoryCount() - 1;
}

int WidgetBoxTreeView::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 WidgetBoxTreeView::indexOfCategory(const QString &name) const
{
    for (int i = 0; i < topLevelItemCount(); ++i) {
        if (topLevelItem(i)->text(0) == name)
            return i;
    }
    return -1;
}

bool WidgetBoxTreeView::load(WidgetBox::LoadMode loadMode)
{
    switch (loadMode) {
    case WidgetBox::LoadReplace:
        clear();
        break;
    case WidgetBox::LoadCustomWidgetsOnly:
        addCustomCategories(true);
        return true;
    default:
        break;
    }

    const QString name = fileName();

    QFile f(name);
    if (!f.open(QIODevice::ReadOnly)) {
        const QString msg = QObject::tr("The widgetbox could not load the file %1.").arg(name);
        return false;
    }
    const QString contents = QString::fromUtf8(f.readAll());
    return loadContents(contents, name);
}

bool WidgetBoxTreeView::loadContents(const QString &contents, const QString &fileName)
{
    QString error_msg;
    int line, col;
    QDomDocument doc;
    if (!doc.setContent(contents, &error_msg, &line, &col)) {
        if (!fileName.isEmpty()) {
            const QString msg = QObject::tr("The widgetbox could not parse the file %1. An error occurred at line %2: %3").
                arg(fileName).arg(line).arg(error_msg);
            qdesigner_internal::designerWarning(msg);
        }
        return false;
    }

    const CategoryList cat_list = domToCategoryList(doc);
    if (cat_list.isEmpty())
        return false;

    foreach(Category cat, cat_list)
        addCategory(cat);

    addCustomCategories(false);
    // Restore which items are expanded
    restoreExpandedState();
    return true;
}

void WidgetBoxTreeView::addCustomCategories(bool replace)
{
    if (replace) {
        // clear out all existing custom widgets
        if (const int numTopLevels =  topLevelItemCount()) {
            for (int t = 0; t < numTopLevels ; ++t) {
                QTreeWidgetItem *topLevel = topLevelItem(t);
                if (const int childCount = topLevel->childCount()) {
                    for (int c = childCount - 1; c >= 0; --c) {
                        QTreeWidgetItem *item = topLevel->child(c);
                        const QDesignerWidgetBoxInterface::Widget wgt = itemToWidget(item);
                        if (!wgt.isNull() && wgt.type() == QDesignerWidgetBoxInterface::Widget::Custom) {
                            delete item;
                            const int listIndex =  m_widgetNames.indexOf(wgt.name());
                            if (listIndex != -1)
                                m_widgetNames.removeAt(listIndex);
                        }
                    }
                }
            }
        }
    }
    // re-add
    foreach (Category cat, loadCustomCategoryList())
        addCategory(cat);
}

QDomDocument WidgetBoxTreeView::categoryListToDom(const CategoryList &cat_list) const
{
    QDomDocument doc;
    QDomElement root = doc.createElement(QLatin1String("widgetbox"));
    doc.appendChild(root);

    const QString name = QLatin1String("name");
    const QString type = QLatin1String("type");
    const QString icon = QLatin1String("icon");
    const QString defaultType = QLatin1String("default");
    const QString category = QLatin1String(QLatin1String("category"));
    const QString iconPrefix = QLatin1String("__qt_icon__");

    foreach (Category cat, cat_list) {
        QDomElement cat_elt = doc.createElement(QLatin1String("category"));
        root.appendChild(cat_elt);
        cat_elt.setAttribute(name, cat.name());
        if (cat.type() == Category::Scratchpad)
            cat_elt.setAttribute(type, QLatin1String("scratchpad"));
        for (int i = 0; i < cat.widgetCount(); ++i) {
           const  Widget wgt = cat.widget(i);
            if (wgt.type() == Widget::Custom)
                continue;

            const DomWidget *dom_wgt = xmlToUi(wgt.name(), widgetDomXml(wgt));
            QDomElement wgt_elt = dom_wgt->write(doc);
            wgt_elt.setAttribute(name, wgt.name());
            const QString iconName = wgt.iconName();
            if (!iconName.startsWith(iconPrefix))
              wgt_elt.setAttribute(icon, wgt.iconName());
            wgt_elt.setAttribute(type, defaultType);
            cat_elt.appendChild(wgt_elt);
            delete dom_wgt;
        }
    }

    return doc;
}

WidgetBoxTreeView::CategoryList
    WidgetBoxTreeView::domToCategoryList(const QDomDocument &doc) const
{
    CategoryList result;

    const QDomElement root = doc.firstChildElement();
    if (root.nodeName() != QLatin1String("widgetbox")) {
        qdesigner_internal::designerWarning(QObject::tr("The file %1 does not appear to be a widgetbox file.").arg(m_file_name));
        return result;
    }

    QDomElement cat_elt = root.firstChildElement();
    for (; !cat_elt.isNull(); cat_elt = cat_elt.nextSiblingElement()) {
        if (cat_elt.nodeName() != QLatin1String("category")) {
            qdesigner_internal::designerWarning(QObject::tr("An error occurred while parsing the file %1: %2 is not a valid child of the root element.").
                                                arg(m_file_name).arg( cat_elt.nodeName()));
            return result;
        }

        const Category cat = domToCategory(cat_elt);
        if (!cat.isNull())
            result.append(cat);
    }

    return result;
}

WidgetBoxTreeView::Category WidgetBoxTreeView::domToCategory(const QDomElement &cat_elt) const
{
    const QString nameAttribute = QLatin1String("name");
    const QString type = QLatin1String("type");
    const QString icon = QLatin1String("icon");
    const QString name = cat_elt.attribute(nameAttribute);
    const QString custom = QLatin1String("custom");

    if (name == QLatin1String("[invisible]"))
        return Category();

    Category result(name);

    if (cat_elt.attribute(type) == QLatin1String("scratchpad"))
        result.setType(Category::Scratchpad);

    QDomElement widget_elt = cat_elt.firstChildElement();
    for (; !widget_elt.isNull(); widget_elt = widget_elt.nextSiblingElement()) {
        const QString type_attr = widget_elt.attribute(type);
        const Widget::Type type = type_attr == custom
                                ? Widget::Custom
                                : Widget::Default;

        const Widget w(widget_elt.attribute(nameAttribute),
                    domToString(widget_elt),
                    widget_elt.attribute(icon),
                    type);
        result.addWidget(w);
    }

    return result;
}

static int findCategory(const QString &name, const WidgetBoxTreeView::CategoryList &list)
{
    int idx = 0;
    foreach (const WidgetBoxTreeView::Category &cat, list) {
        if (cat.name() == name)
            return idx;
        ++idx;
    }
    return -1;
}

WidgetBoxTreeView::CategoryList WidgetBoxTreeView::loadCustomCategoryList() const
{
    CategoryList result;

    QDesignerPluginManager *pm = m_core->pluginManager();

    const QList<QDesignerCustomWidgetInterface*> customWidgets = pm->registeredCustomWidgets();

    static const QString customCatName = tr("Custom Widgets");
    const QString invisible = QLatin1String("[invisible]");
    const QString iconPrefix = QLatin1String("__qt_icon__");

    foreach (const QDesignerCustomWidgetInterface *c, customWidgets) {
        const QString dom_xml = c->domXml();
        if (dom_xml.isEmpty())
            continue;

        QString cat_name = c->group();
        if (cat_name.isEmpty())
            cat_name = customCatName;
        else if (cat_name == invisible)
            continue;

        int idx = findCategory(cat_name, result);
        if (idx == -1) {
            result.append(Category(cat_name));
            idx = result.size() - 1;
        }
        Category &cat = result[idx];

        const QIcon icon = c->icon();

        QString icon_name;
        if (icon.isNull())
            icon_name = QLatin1String("qtlogo.png");
        else {
            icon_name = iconPrefix;
            icon_name += c->name();
            m_pluginIcons.insert(icon_name, icon);
        }

        cat.addWidget(Widget(c->name(), dom_xml, icon_name, Widget::Custom));
    }

    return result;
}

QTreeWidgetItem *WidgetBoxTreeView::widgetToItem(const Widget &wgt,
                                                    QTreeWidgetItem *parent,
                                                    bool editable)
{
    if (!editable && m_widgetNames.contains(wgt.name()))
        return 0;

    QTreeWidgetItem *item = new QTreeWidgetItem(parent);
    item->setFlags(item->flags() & ~Qt::ItemIsSelectable);

    QString icon_name = wgt.iconName();
    if (icon_name.isEmpty())
        icon_name = QLatin1String("qtlogo.png");

    const bool block = blockSignals(true);
    item->setText(0, wgt.name());

    if (!editable)
        m_widgetNames.append(wgt.name());

    QIcon icon;
    if (icon_name.startsWith(QLatin1String("__qt_icon__")))
      icon = m_pluginIcons.value(icon_name);
    if (icon.isNull())
      icon = createIconSet(icon_name);
    item->setIcon(0, icon);
    item->setData(0, Qt::UserRole, qVariantFromValue(wgt));

    const QDesignerWidgetDataBaseInterface *db = m_core->widgetDataBase();
    const int dbIndex = db->indexOfClassName(wgt.name());
    if (dbIndex != -1) {
        const QDesignerWidgetDataBaseItemInterface *dbItem = db->item(dbIndex);
        const QString toolTip = dbItem->toolTip();
        if (!toolTip.isEmpty())
            item->setToolTip(0, toolTip);
        const QString whatsThis = dbItem->whatsThis();
        if (!whatsThis.isEmpty())
            item->setWhatsThis(0, whatsThis);
    }

    blockSignals(block);

    if (editable) {
        item->setFlags(Qt::ItemIsSelectable
                        | Qt::ItemIsEditable
                        | Qt::ItemIsEnabled);
    }

    return item;
}

WidgetBoxTreeView::Widget WidgetBoxTreeView::itemToWidget(const QTreeWidgetItem *item)
{
    return qvariant_cast<Widget>(item->data(0, Qt::UserRole));
}

int WidgetBoxTreeView::categoryCount() const
{
    return topLevelItemCount();
}

WidgetBoxTreeView::Category WidgetBoxTreeView::category(int cat_idx) const
{
    Category result;

    if (cat_idx >= topLevelItemCount())
        return result;

    QTreeWidgetItem *cat_item = topLevelItem(cat_idx);
    result.setName(cat_item->text(0));

    for (int i = 0; i < cat_item->childCount(); ++i) {
        QTreeWidgetItem *child = cat_item->child(i);
        result.addWidget(itemToWidget(child));
    }