objectinspector.cpp

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

            }
        } else {
            QList<QObject*> children = object->children();
            qSort(children.begin(), children.end(), ObjectInspector::sortEntry);

            foreach (QObject *child, children) {
                QWidget *widget = qobject_cast<QWidget*>(child);
                if (!widget || !fw->isManaged(widget))
                    continue;

                QTreeWidgetItem *childItem = new QTreeWidgetItem(item);
                workingList.append(qMakePair(childItem, child));
            }

            if (QWidget *widget = qobject_cast<QWidget*>(object)) {
                QList<QAction*> actions = widget->actions();
                foreach (QAction *action, actions) {
                    if (!fw->core()->metaDataBase()->item(action))
                        continue;

                    QObject *obj = action;
                    if (action->menu())
                        obj = action->menu();

                    QTreeWidgetItem *childItem = new QTreeWidgetItem(item);
                    workingList.append(qMakePair(childItem, obj));
                }
            }
        }

        m_treeWidget->expandItem(item);
    }

    m_treeWidget->horizontalScrollBar()->setValue(xoffset);
    m_treeWidget->verticalScrollBar()->setValue(yoffset);

    switch (selectionList.size()) {
    case 0:
        break;
    case 1:
        m_treeWidget->scrollToItem(selectionList[0]);
        m_treeWidget->setCurrentItem(selectionList[0]);
        break;
    default:
        foreach (QTreeWidgetItem* item, selectionList) {
            item->setSelected(true);
        }
        m_treeWidget->scrollToItem(selectionList[0]);
        break;
    }

    m_treeWidget->setUpdatesEnabled(true);
    m_treeWidget->update();

    if (resizeToColumn) {
        m_treeWidget->resizeColumnToContents(0);
    } else {
        m_treeWidget->setColumnWidth(0, oldWidth);
    }
    m_treeWidget->selectionModel()->blockSignals(selectionBlocked);
}

void ObjectInspector::showContainersCurrentPage(QWidget *widget)
{
    if (!widget)
        return;

    FormWindow *fw = FormWindow::findFormWindow(widget);
    if (!fw)
        return;

    QWidget *w = widget->parentWidget();
    while (1) {
        if (fw->isMainContainer(w))
            return;

        if (!w)
            return;

        QDesignerContainerExtension *c = qt_extension<QDesignerContainerExtension*>(core()->extensionManager(), w);
        if (c && !c->widget(c->currentIndex())->isAncestorOf(widget)) {
            for (int i = 0; i < c->count(); i++)
                if (c->widget(i)->isAncestorOf(widget)) {
                    c->setCurrentIndex(i);
                    break;
                }
        }
        w = w->parentWidget();
    }
}

void ObjectInspector::slotSelectionChanged(const QItemSelection & /*selected*/, const QItemSelection &/*deselected*/)
{
    if (!m_formWindow)
        return;

    Selection selection;
    getSelection(selection);

    if (!selection.m_cursorSelection.isEmpty())
        showContainersCurrentPage(selection.m_cursorSelection.last());
    if (!selection.m_selectedObjects.isEmpty())
        showContainersCurrentPage(qobject_cast<QWidget *>(selection.m_selectedObjects[0]));

    m_formWindow->clearSelection(false);

    if (!selection.m_cursorSelection.empty()) {

        // This will trigger an update
        foreach (QWidget* widget, selection.m_cursorSelection) {
            m_formWindow->selectWidget(widget);
        }
    } else {
        if (!selection.m_selectedObjects.empty()) {
            // refresh at least the property editor
            core()->propertyEditor()->setObject(selection.m_selectedObjects[0]);
            core()->propertyEditor()->setEnabled(selection.m_selectedObjects.size());
        }
    }
    QMetaObject::invokeMethod(m_formWindow->core()->formWindowManager(), "slotUpdateActions");
}

void ObjectInspector::getSelection(Selection &s) const
{
    s.clear();

    if (!m_formWindow)
        return;

    const QList<QTreeWidgetItem*> items = m_treeWidget->selectedItems();
    if (items.empty())
        return;

    // sort objects
    foreach (QTreeWidgetItem *item, items)
        if (QObject *object = objectOfItem(item))
            switch (selectionType(m_formWindow, object)) {
            case NoSelection:
                break;
            case QObjectSelection:
            case UnmanagedWidgetSelection:
                // It is actually possible to select an action
                // twice if it is in a menu bar and in a tool bar.
                if (!s.m_selectedObjects.contains(object))
                    s.m_selectedObjects.push_back(object);
                break;
            case ManagedWidgetSelection:
                s.m_cursorSelection.push_back(qobject_cast<QWidget *>(object));
                break;
            }
}

void ObjectInspector::findRecursion(QTreeWidgetItem *item, QObject *o,  ItemList &matchList)
{
    if (objectOfItem(item) == o)
        matchList += item;

    if (const int cc = item->childCount())
        for (int i = 0;i < cc; i++)
            findRecursion(item->child(i), o, matchList);
}

ObjectInspector::ItemList ObjectInspector::findItemsOfObject(QObject *o) const
{
    ItemList rc;
    if (const int tlc = m_treeWidget->topLevelItemCount())
        for (int i = 0;i < tlc; i++)
            findRecursion(m_treeWidget->topLevelItem (i), o, rc);
    return rc;
}

bool ObjectInspector::selectObject(QObject *o)
{
    if (!core()->metaDataBase()->item(o))
        return false;

    const ItemList items = findItemsOfObject(o);
    if (items.empty())
        return false;

    // Change in selection?
    const  ItemList currentSelectedItems = m_treeWidget->selectedItems();
    if (!currentSelectedItems.empty() && currentSelectedItems.toSet() == items.toSet()) {
        return true;
    }
    // do select and update
    m_treeWidget->clearSelection();
    const ItemList::const_iterator cend = items.constEnd();
    for (ItemList::const_iterator it = items.constBegin(); it != cend; ++it )  {
        (*it)->setSelected(true);
    }
    m_treeWidget->scrollToItem(items.first());
    return true;
}

void ObjectInspector::clearSelection()
{
    m_treeWidget->clearSelection();
}

void ObjectInspector::slotHeaderDoubleClicked(int column)
{
    m_treeWidget->resizeColumnToContents(column);
}

QWidget *ObjectInspector::managedWidgetAt(const QPoint &global_mouse_pos)
{
    if (!m_formWindow)
        return 0;

    const  QPoint pos = m_treeWidget->viewport()->mapFromGlobal(global_mouse_pos);
    QTreeWidgetItem *item = m_treeWidget->itemAt(pos);
    if (!item)
        return 0;

    QObject *o = objectOfItem(item);
    if (!o->isWidgetType())
        return 0;
    QWidget *rc = qobject_cast<QWidget *>(o);
    if (!m_formWindow->isManaged(rc))
        return 0;
    return rc;
}

void ObjectInspector::mainContainerChanged()
{
    // Invalidate references to objects kept in items
    if (sender() == m_formWindow)
        setFormWindow(0);
}

void  ObjectInspector::dragEnterEvent (QDragEnterEvent * event)
{
    handleDragEnterMoveEvent(event, true);
}

void  ObjectInspector::dragMoveEvent(QDragMoveEvent * event)
{
    handleDragEnterMoveEvent(event, false);
}

void  ObjectInspector::dragLeaveEvent(QDragLeaveEvent * /* event*/)
{
    restoreDropHighlighting();
}

// Return an offset for dropping.
// Position the dropped widget with form grid offset to avoid overlapping unless we
// drop on a layout. Position doesn't matter there
// and it enables us to drop on a squeezed layout widget

static inline QPoint dropPointOffset(const FormWindowBase *fw, const QWidget *dropTarget)
{
    if (!dropTarget || dropTarget->layout())
        return QPoint(0, 0);
    return QPoint(fw->designerGrid().deltaX(), fw->designerGrid().deltaY());
}

void  ObjectInspector::dropEvent (QDropEvent * event)
{
    if (!m_formWindow || !m_formFakeDropTarget) {
        event->ignore();
        return;
    }

    const QDesignerMimeData *mimeData =  qobject_cast<const QDesignerMimeData *>(event->mimeData());
    if (!mimeData) {
        event->ignore();
        return;
    }
    const QPoint fakeGlobalDropFormPos = m_formFakeDropTarget->mapToGlobal(dropPointOffset(m_formWindow , m_formFakeDropTarget));
    mimeData->moveDecoration(fakeGlobalDropFormPos + mimeData->hotSpot());
    if (!m_formWindow->dropWidgets(mimeData->items(), m_formFakeDropTarget, fakeGlobalDropFormPos)) {
        event->ignore();
        return;
    }
    mimeData->acceptEvent(event);
}

void ObjectInspector::handleDragEnterMoveEvent(QDragMoveEvent * event, bool isDragEnter)
{
    if (!m_formWindow) {
        event->ignore();
        return;
    }

    const QDesignerMimeData *mimeData =  qobject_cast<const QDesignerMimeData *>(event->mimeData());
    if (!mimeData) {
        event->ignore();
        return;
    }

    QWidget *dropTarget = 0;
    QPoint fakeDropTargetOffset = QPoint(0, 0);
    if (QWidget *managedWidget = managedWidgetAt(mapToGlobal(event->pos()))) {
        fakeDropTargetOffset = dropPointOffset(m_formWindow, managedWidget);
        // pretend we drag over the managed widget on the form
        const QPoint fakeFormPos = m_formWindow->mapFromGlobal(managedWidget->mapToGlobal(fakeDropTargetOffset));
        const FormWindowBase::WidgetUnderMouseMode wum = mimeData->items().size() == 1 ? FormWindowBase::FindSingleSelectionDropTarget : FormWindowBase::FindMultiSelectionDropTarget;
        dropTarget = m_formWindow->widgetUnderMouse(fakeFormPos, wum);
    }

    if (m_formFakeDropTarget && dropTarget != m_formFakeDropTarget)
        m_formWindow->highlightWidget(m_formFakeDropTarget, fakeDropTargetOffset, FormWindow::Restore);

    m_formFakeDropTarget =  dropTarget;
    if (m_formFakeDropTarget)
        m_formWindow->highlightWidget(m_formFakeDropTarget, fakeDropTargetOffset, FormWindow::Highlight);

    // Do not refuse enter even if the area is not droppable
    if (isDragEnter || m_formFakeDropTarget)
        mimeData->acceptEvent(event);
    else
        event->ignore();
}

void ObjectInspector::restoreDropHighlighting()
{
    if (m_formFakeDropTarget) {
        if (m_formWindow) {
            m_formWindow->highlightWidget(m_formFakeDropTarget, QPoint(5, 5), FormWindow::Restore);
        }
        m_formFakeDropTarget = 0;
    }
}
}