从源头看Dust3d | （七）materialListWidget（2）

2021SC@SDUSC

8.isMaterialSelected

bool MaterialListWidget::isMaterialSelected(QUuid materialId)
{
    return (m_currentSelectedMaterialId == materialId ||
        m_selectedMaterialIds.find(materialId) != m_selectedMaterialIds.end());
}

9.showContextMenu

void MaterialListWidget::showContextMenu(const QPoint &pos)
{
    if (!m_hasContextMenu)
        return;

    QMenu contextMenu(this);

    std::set unorderedMaterialIds = m_selectedMaterialIds;
    if (!m_currentSelectedMaterialId.isNull())
        unorderedMaterialIds.insert(m_currentSelectedMaterialId);

    std::vector materialIds;
    for (const auto &cand: m_document->materialIdList) {
        if (unorderedMaterialIds.find(cand) != unorderedMaterialIds.end())
            materialIds.push_back(cand);
    }

    QAction modifyAction(tr("Modify"), this);
    if (materialIds.size() == 1) {
        connect(&modifyAction, &QAction::triggered, this, [=]() {
            emit modifyMaterial(*materialIds.begin());
        });
        contextMenu.addAction(&modifyAction);
    }

    QAction copyAction(tr("Copy"), this);
    if (!materialIds.empty()) {
        connect(©Action, &QAction::triggered, this, &MaterialListWidget::copy);
        contextMenu.addAction(©Action);
    }

    QAction pasteAction(tr("Paste"), this);
    if (m_document->hasPastableMaterialsInClipboard()) {
        connect(&pasteAction, &QAction::triggered, m_document, &document::paste);
        contextMenu.addAction(&pasteAction);
    }

    QAction deleteAction(tr("Delete"), this);
    if (!materialIds.empty()) {
        connect(&deleteAction, &QAction::triggered, [=]() {
            for (const auto &materialId: materialIds)
                emit removeMaterial(materialId);
        });
        contextMenu.addAction(&deleteAction);
    }

    contextMenu.exec(mapToGlobal(pos));
}

10.resizeEvent

void MaterialListWidget::resizeEvent(QResizeEvent *event)
{
    QTreeWidget::resizeEvent(event);
    if (calculateColumnCount() != columnCount())
        reload();
}

11.calculateColumnCount

int MaterialListWidget::calculateColumnCount()
{
    if (nullptr == parentWidget())
        return 0;

    int columns = parentWidget()->width() / Theme::materialPreviewImageSize;
    if (0 == columns)
        columns = 1;
    return columns;
}

12.reload

void MaterialListWidget::reload()
{
    removeAllContent();

    int columns = calculateColumnCount();
    if (0 == columns)
        return;

    int columnWidth = parentWidget()->width() / columns;

    //qDebug() << "parentWidth:" << parentWidget()->width() << "columnWidth:" << columnWidth << "columns:" << columns;

    setColumnCount(columns);
    for (int i = 0; i < columns; i++)
        setColumnWidth(i, columnWidth);
    
    std::vector orderedMaterialIdList = m_document->materialIdList;
    std::sort(orderedMaterialIdList.begin(), orderedMaterialIdList.end(), [&](const QUuid &firstMaterialId, const QUuid &secondMaterialId) {
        const auto *firstMaterial = m_document->findMaterial(firstMaterialId);
        const auto *secondMaterial = m_document->findMaterial(secondMaterialId);
        if (nullptr == firstMaterial || nullptr == secondMaterial)
            return false;
        return QString::compare(firstMaterial->name, secondMaterial->name, Qt::CaseInsensitive) < 0;
    });

    decltype(orderedMaterialIdList.size()) materialIndex = 0;
    while (materialIndex < orderedMaterialIdList.size()) {
        QTreeWidgetItem *item = new QTreeWidgetItem(this);
        item->setFlags((item->flags() | Qt::ItemIsEnabled) & ~(Qt::ItemIsSelectable) & ~(Qt::ItemIsEditable));
        for (int col = 0; col < columns && materialIndex < orderedMaterialIdList.size(); col++, materialIndex++) {
            const auto &materialId = orderedMaterialIdList[materialIndex];
            item->setSizeHint(col, QSize(columnWidth, MaterialWidget::preferredHeight() + 2));
            item->setData(col, Qt::UserRole, materialId.toString());
            MaterialWidget *widget = new MaterialWidget(m_document, materialId);
            connect(widget, &MaterialWidget::modifyMaterial, this, &MaterialListWidget::modifyMaterial);
            connect(widget, &MaterialWidget::cornerButtonClicked, this, &MaterialListWidget::cornerButtonClicked);
            setItemWidget(item, col, widget);
            widget->reload();
            widget->updateCheckedState(isMaterialSelected(materialId));
            m_itemMap[materialId] = std::make_pair(item, col);
        }
        invisibleRootItem()->addChild(item);
    }
}

13.setCornerButtonVisible

void MaterialListWidget::setCornerButtonVisible(bool visible)
{
    m_cornerButtonVisible = visible;
}

void MaterialListWidget::setHasContextMenu(bool hasContextMenu)
{
    m_hasContextMenu = hasContextMenu;
}

void MaterialListWidget::removeAllContent()
{
    m_itemMap.clear();
    clear();
}

14.copy

void MaterialListWidget::copy()
{
    if (m_selectedMaterialIds.empty() && m_currentSelectedMaterialId.isNull())
        return;

    std::set limitMaterialIds = m_selectedMaterialIds;
    if (!m_currentSelectedMaterialId.isNull())
        limitMaterialIds.insert(m_currentSelectedMaterialId);

    std::set emptySet;

    Snapshot snapshot;
    m_document->toSnapshot(&snapshot, emptySet, documentToSnapshotFor::Materials,
        emptySet, limitMaterialIds);
    QString snapshotXml;
    QXmlStreamWriter xmlStreamWriter(&snapshotXml);
    saveSkeletonToXmlStream(&snapshot, &xmlStreamWriter);
    QClipboard *clipboard = QApplication::clipboard();
    clipboard->setText(snapshotXml);
}