void ArchiveList::updateArchives(QList<Archive *> archivesOrig) { QSet<QString> expandedLanguages; QSet<QString> knownLanguages; QSet<ArchiveID> expandedItems; for (int i = 0; i < topLevelItemCount(); i ++) { QTreeWidgetItem *langItem = topLevelItem(i); const QString &lang = langItem->text(0); if (langItem->isExpanded()) expandedLanguages += lang; knownLanguages += lang; for (int j = 0; j < langItem->childCount(); j ++) { QTreeWidgetItem *dateItem = langItem->child(j); if (dateItem->isExpanded()) expandedItems += ArchiveID(lang, dateItem->text(0)); } } clear(); QList<Archive *> archives(archivesOrig); qSort(archives.begin(), archives.end(), Archive::comparePointers); QTreeWidgetItem *topItem(0); QString lastLanguage; foreach (Archive *a, archives) { if (lastLanguage != a->getLanguage() || a->getLanguage().isEmpty()) { lastLanguage = a->getLanguage(); topItem = new QTreeWidgetItem(this, QStringList() << lastLanguage); addTopLevelItem(topItem); if (expandedLanguages.contains(lastLanguage)) topItem->setExpanded(true); } QTreeWidgetItem *item = new QTreeWidgetItem(topItem); item->setText(0, a->getDate()); if (expandedItems.contains(a->getID())) item->setExpanded(true); if (qobject_cast<DownloadableArchive *>(a)) { fillDownloadableArchiveItem(static_cast<DownloadableArchive *>(a), item); } else if (qobject_cast<PartialArchive *>(a)) { if (!knownLanguages.contains(a->getLanguage())) topItem->setExpanded(true); fillPartialArchiveItem(static_cast<PartialArchive *>(a), item); } else if (qobject_cast<LocalArchive *>(a)) { if (!knownLanguages.contains(a->getLanguage())) topItem->setExpanded(true); fillLocalArchiveItem(static_cast<LocalArchive *>(a), item); } } resizeColumnToContents(0); resizeColumnToContents(1); resizeColumnToContents(2); resizeColumnToContents(3); }
void Parametertuner::moveSelection(int dir) { QTreeWidgetItem* thisItem = getSelectedItem(); if (!thisItem) { m_ui.parameter_root_widget->topLevelItem(0)->setSelected(true); return; } QTreeWidgetItem* parent = thisItem->parent(); QTreeWidgetItem* nextItem; if (!parent) { parent = m_ui.parameter_root_widget->invisibleRootItem(); } int thisItemIndex = parent->indexOfChild(thisItem); if (thisItem->isExpanded() && dir == DOWN) { nextItem = thisItem->child(0); updateSelection(thisItem, nextItem); return; } else if (!parent->child(thisItemIndex + dir)) { updateSelection(thisItem, parent); return; } else { nextItem = parent->child(thisItemIndex + dir); updateSelection(thisItem, nextItem); return; } }
//------------------------------------------------------------------------------- void DialogSelectMetar::slotBtOK() { QTreeWidgetItemIterator iter (treeWidget); QTreeWidgetItem *it; QString val; QStringList expandedlist, icaolist; // Write expanded items in settings while (*iter) { it = *iter; if (it->data(0, Qt::UserRole) == "country" || it->data(0, Qt::UserRole) == "state") { if (it->isExpanded()) { val = (it->data(0, Qt::UserRole+1)).toString(); expandedlist << val; } } iter ++; } iter = QTreeWidgetItemIterator (treeWidget, QTreeWidgetItemIterator::Checked); while (*iter) { it = *iter; if (it->data(0, Qt::UserRole) == "icao") { val = (it->data(0, Qt::UserRole+1)).toString(); icaolist << val; } iter ++; } Util::setSetting ("metar_country_expanded", expandedlist); Util::setSetting ("metar_selected", icaolist); emit metarListChanged (); Util::setSetting ("metar_tree_offset", treeWidget->verticalScrollBar()->sliderPosition()); accept(); }
bool QTreeWidgetItemProto::isExpanded() const { QTreeWidgetItem *item = qscriptvalue_cast<QTreeWidgetItem*>(thisObject()); if (item) return item->isExpanded(); return false; }
bool QgsAppLegendInterface::isGroupExpanded( int groupIndex ) { QTreeWidgetItem * item = getItem (groupIndex); if ( !item ) { return false; } return item->isExpanded(); }
bool BasketListViewItem::isShown() { QTreeWidgetItem *item = parent(); while (item) { if (!item->isExpanded()) return false; item = item->parent(); } return true; }
/* Store in 'set' the tag IDs of the items that are in expanded state and are descendants of 'parent' */ void query_listview::store_expanded_state(QTreeWidgetItem* parent, QSet<uint>* set) { for (int i=0; i<parent->childCount(); ++i) { QTreeWidgetItem* item = parent->child(i); if (item->isExpanded()) { query_tag_lvitem* t = static_cast<query_tag_lvitem*>(item); set->insert(t->m_tag_id); } if (item->childCount()>0) store_expanded_state(item, set); } }
void Parametertuner::ChangeValue(int dir) { QTreeWidgetItem* thisItem; if (!(thisItem = getSelectedItem())) return; if (thisItem->childCount() != 0) { if (dir == RIGHT && (!thisItem->isExpanded())) thisItem->setExpanded(true); else if (dir == LEFT && thisItem->isExpanded()) thisItem->setExpanded(false); return; } ParameterWidgetBase* param; param = (ParameterWidgetBase *)m_ui.parameter_root_widget->itemWidget(thisItem, 1); if (!param) return; if (dir == LEFT) param->DecValue(); else param->IncValue(); }
dmz::V8Value dmz::JsModuleUiV8QtBasic::_tree_item_is_expanded (const v8::Arguments &Args) { v8::HandleScope scope; V8Value result = v8::Undefined (); JsModuleUiV8QtBasic *self = _to_self (Args); if (self) { QTreeWidgetItem *item = self->_to_qtreewidgetitem (Args.This ()); if (item) { result = v8::Boolean::New (item->isExpanded ()); } } return scope.Close (result); }
void HierarchyTreeControl::HandleDragMoveControlMimeData(QDragMoveEvent *event, const ControlMimeData* /*mimeData*/) { DropIndicatorPosition position = dropIndicatorPosition(); Logger::Warning("POSITION TYPE^ %i", position); // Where we are in tree? QTreeWidgetItem* item = itemAt(event->pos()); if (!item) { HierarchyTreeController::Instance()->ResetSelectedControl(); return; } HierarchyTreeNode::HIERARCHYTREENODEID insertInto = HierarchyTreeNode::HIERARCHYTREENODEID_EMPTY; QVariant data = item->data(ITEM_ID); insertInto = data.toInt(); // Handle specific types of nodes. HierarchyTreeNode* nodeToInsertControlTo = HierarchyTreeController::Instance()->GetTree().GetNode(insertInto); if (dynamic_cast<HierarchyTreePlatformNode*>(nodeToInsertControlTo) || dynamic_cast<HierarchyTreeAggregatorControlNode*>(nodeToInsertControlTo)) { // Don't allow to drop the controls directly to Platform or Aggregator. HierarchyTreeController::Instance()->ResetSelectedControl(); return; } // Expand the items while dragging control on them. if (!item->isExpanded()) { item->setExpanded(true); } scrollTo(indexAt(event->pos())); HierarchyTreeControlNode* controlNode = dynamic_cast<HierarchyTreeControlNode*>(nodeToInsertControlTo); if (controlNode) { // Don't reselect the same control, if it is already selected. if (!HierarchyTreeController::Instance()->IsControlSelected(controlNode)) { HierarchyTreeController::Instance()->ResetSelectedControl(); HierarchyTreeController::Instance()->SelectControl(controlNode); } } event->accept(); }
QList<QTreeWidgetItem *> FeedListWidget::getAllOpenedFolders(QTreeWidgetItem *parent) const { QList<QTreeWidgetItem *> openedFolders; int nbChildren = (parent ? parent->childCount() : topLevelItemCount()); for (int i = 0; i < nbChildren; ++i) { QTreeWidgetItem *item (parent ? parent->child(i) : topLevelItem(i)); if (isFolder(item) && item->isExpanded()) { QList<QTreeWidgetItem *> openedSubfolders = getAllOpenedFolders(item); if (!openedSubfolders.empty()) openedFolders << openedSubfolders; else openedFolders << item; } } return openedFolders; }
void rightclick_tree_widget::mousePressEvent(QMouseEvent *event) { if (event->button() != Qt::RightButton) { QTreeWidget::mousePressEvent(event); return; } QTreeWidgetItem *item = itemAt(event->pos()); if (item) { #if QT_VERSION >= 0x040200 gui->expand_all_elements(item, !item->isExpanded()); #else // QT_VERSION >= 0x040200 gui->expand_all_elements(item, !item->treeWidget()->isItemExpanded(item)); #endif // QT_VERSION >= 0x040200 } }
// move an item one position up void UserMenuTree::itemUp() { QTreeWidgetItem *current = currentItem(); UserMenuItem *aboveitem = dynamic_cast<UserMenuItem *>(itemAbove(current)); if (!aboveitem) { return; } bool expanded = current->isExpanded(); blockSignals(true); QTreeWidgetItem *aboveparent = aboveitem->parent(); int aboveindex = itemIndex(aboveparent,aboveitem); UserMenuItem *parent = dynamic_cast<UserMenuItem *>(current->parent()); int index = itemIndex(parent,current); takeItem(parent,current); if ( parent!=aboveparent && index!=0 ) { aboveindex++; } if ( parent==aboveparent && aboveitem->menutype()==UserMenuData::Submenu ) { insertItem(aboveitem,0,current); } else { insertItem(aboveparent,aboveindex,current); } // update model data of old and new parent, if it has changed UserMenuItem *newparent = dynamic_cast<UserMenuItem *>(current->parent()); if ( parent != newparent ) { if ( parent ) { parent->setModelData(); parent->setText(0, parent->updateMenutitle()); } if ( newparent ) { newparent->setModelData(); newparent->setText(0, newparent->updateMenutitle()); } } current->setExpanded(expanded); setCurrentItem(current); blockSignals(false); }
// move an item one position down void UserMenuTree::itemDown() { QTreeWidgetItem *current = currentItem(); bool expanded = current->isExpanded(); blockSignals(true); // get all necessary parameter UserMenuItem *parent = dynamic_cast<UserMenuItem *>(current->parent()); int index = itemIndex(parent,current); int children = numChildren(parent); // successor exists? if ( index < children-1 ) { UserMenuItem *successor = dynamic_cast<UserMenuItem *>( itemAtIndex(parent,index+1) ); takeItem(parent,current); if ( successor->menutype() == UserMenuData::Submenu ) { successor->insertChild(0,current); } else { insertItem(parent,index+1,current); } } else if ( parent ) { QTreeWidgetItem *grandparent = parent->parent(); int parentindex = itemIndex(grandparent,parent); takeItem(parent,current); insertItem(grandparent,parentindex+1,current); } // update model data of old and new parent, if it has changed UserMenuItem *newparent = dynamic_cast<UserMenuItem *>(current->parent()); if ( parent != newparent ) { if ( parent ) { parent->setModelData(); parent->setText(0, parent->updateMenutitle()); } if ( newparent ) { newparent->setModelData(); newparent->setText(0, newparent->updateMenutitle()); } } current->setExpanded(expanded); setCurrentItem(current); blockSignals(false); }
void MotionPlanningFrame::populatePlanningSceneTreeView() { moveit_warehouse::PlanningSceneStoragePtr planning_scene_storage = planning_scene_storage_; if (!planning_scene_storage) return; ui_->planning_scene_tree->setUpdatesEnabled(false); // remember which items were expanded std::set<std::string> expanded; for (int i = 0; i < ui_->planning_scene_tree->topLevelItemCount(); ++i) { QTreeWidgetItem* it = ui_->planning_scene_tree->topLevelItem(i); if (it->isExpanded()) expanded.insert(it->text(0).toStdString()); } ui_->planning_scene_tree->clear(); std::vector<std::string> names; planning_scene_storage->getPlanningSceneNames(names); for (const std::string& name : names) { std::vector<std::string> query_names; planning_scene_storage->getPlanningQueriesNames(query_names, name); QTreeWidgetItem* item = new QTreeWidgetItem(ui_->planning_scene_tree, QStringList(QString::fromStdString(name)), ITEM_TYPE_SCENE); item->setFlags(item->flags() | Qt::ItemIsEditable); item->setToolTip(0, item->text(0)); // we use the tool tip as a backup of the old name when renaming for (const std::string& query_name : query_names) { QTreeWidgetItem* subitem = new QTreeWidgetItem(item, QStringList(QString::fromStdString(query_name)), ITEM_TYPE_QUERY); subitem->setFlags(subitem->flags() | Qt::ItemIsEditable); subitem->setToolTip(0, subitem->text(0)); item->addChild(subitem); } ui_->planning_scene_tree->insertTopLevelItem(ui_->planning_scene_tree->topLevelItemCount(), item); if (expanded.find(name) != expanded.end()) ui_->planning_scene_tree->expandItem(item); } ui_->planning_scene_tree->sortItems(0, Qt::AscendingOrder); ui_->planning_scene_tree->setUpdatesEnabled(true); checkPlanningSceneTreeEnabledButtons(); }
AddFixture::~AddFixture() { QSettings settings; settings.setValue(SETTINGS_GEOMETRY, saveGeometry()); QList<QVariant> expanded; QTreeWidgetItem * root = m_tree->invisibleRootItem(); for (int i=0; i < root->childCount(); i++) { QTreeWidgetItem * manuf = root->child(i); if (manuf->isExpanded()) { expanded << manuf->text(KColumnName); } } settings.setValue(SETTINGS_EXPANDED, expanded); }
int treeWidgetToTextTable(QTreeWidgetItem *item, QTextTable *table, int rowNum) { for (int c = 0; c < item->childCount(); ++c) { QTreeWidgetItem *child = item->child(c); //export child table->appendRows(1); for (int colNum = 0; colNum < child->columnCount(); ++colNum) { table->cellAt(rowNum, colNum).firstCursorPosition().insertText(child->text(colNum)); } ++rowNum; //recurse to children if (child->isExpanded() && child->childCount() > 0) { rowNum = treeWidgetToTextTable(child, table, rowNum); } } return rowNum; }
void ODBC_Connection::SaveGui() { m_sCurrentStatement = m_ui.SQLCommandTextEdit->toPlainText(); m_sLogFile = m_ui.SQLLogTextBrowser->toHtml(); m_lExpandedTables.clear(); for (int i = 0, count = m_db.tables().count(); i < count; i++) { QString sTableName = m_db.tables().value(i); QList<QTreeWidgetItem*> lItems = m_ui.TableTreeWidget->findItems(sTableName, Qt::MatchExactly); if (lItems.count() > 0) { QTreeWidgetItem *pItem = lItems.value(0); if (pItem == NULL) return; if (pItem->isExpanded()) m_lExpandedTables << pItem->text(0); } } }
void QtPropertyEditorView::mousePressEvent(QMouseEvent *event) { QTreeWidget::mousePressEvent(event); QTreeWidgetItem *item = itemAt(event->pos()); if (item) { if ((item != m_editorPrivate->editedItem()) && (event->button() == Qt::LeftButton) && (header()->logicalIndexAt(event->pos().x()) == 1) && ((item->flags() & (Qt::ItemIsEditable | Qt::ItemIsEnabled)) == (Qt::ItemIsEditable | Qt::ItemIsEnabled))) { editItem(item, 1); } else if (!m_editorPrivate->hasValue(item) && m_editorPrivate->markPropertiesWithoutValue() && !rootIsDecorated()) { if (event->pos().x() + header()->offset() < 20) item->setExpanded(!item->isExpanded()); } } }
void QtPropertyTreeView::mousePressEvent(QMouseEvent *event) { QTreeWidget::mousePressEvent(event); QTreeWidgetItem *item = itemAt(event->pos()); if (item) { QtProperty *property = editorPrivate_->itemToProperty(item); if ((item != editorPrivate_->getEditedItem()) && (event->button() == Qt::LeftButton) && (header()->logicalIndexAt(event->pos().x()) == 1) && isItemEditable(item->flags())) { editItem(item, 1); } else if (property && !property->hasValue() && editorPrivate_->markPropertiesWithoutValue() && !rootIsDecorated()) { if (event->pos().x() + header()->offset() < 20) item->setExpanded(!item->isExpanded()); } } }
void NotebookList::notebookSelected(QModelIndex idx) { QTreeWidgetItem *item = itemFromIndex(idx); QString fullFilePath=""; if(lastSelectedItem) lastSelectedItem->setBackground(0,QBrush(QColor(Qt::white))); item->setBackground(0,QBrush(QColor(Qt::yellow))); lastSelectedItem = item; if(item->whatsThis(0) == "folder"){ if(item->isExpanded()) item->setExpanded(false); else item->setExpanded(true); return; } if (textEditorWindow->textEdit->document()->isModified()) textEditorWindow->fileSave(); while (idx != QModelIndex()) { QString itemName = this->model()->data(idx).toString(); if (fullFilePath == "") fullFilePath = itemName; else fullFilePath = itemName + "/" + fullFilePath; idx = idx.parent(); } fullFilePath = baseDirectory + fullFilePath + extensionName; cout << "full path : "<<fullFilePath.toAscii().data()<<endl; QString lastModifiedDate = svnController->getDateInfo(fullFilePath); textEditorWindow->statusBar()->showMessage(lastModifiedDate,0); textEditorWindow->load(fullFilePath); }
QRect fullCategoryRect(const QStyleOptionViewItem& option, const QModelIndex& index) const { QModelIndex i = index; if (i.parent().isValid()) { i = i.parent(); } QTreeWidgetItem* item = m_tree->itemFromIndex(i); QRect r = m_tree->visualItemRect(item); // adapt width r.setLeft(m_categoryDrawer.leftMargin()); r.setWidth(m_tree->viewport()->width() - m_categoryDrawer.leftMargin() - m_categoryDrawer.rightMargin()); // adapt height if (item->isExpanded() && item->childCount() > 0) { const int childCount = item->childCount(); const int h = sizeHint(option, index.child(0, 0)).height(); r.setHeight(r.height() + childCount * h); } r.setTop(r.top() + m_categoryDrawer.leftMargin()); return r; }
void VDirectoryTree::keyPressEvent(QKeyEvent *event) { int key = event->key(); int modifiers = event->modifiers(); switch (key) { case Qt::Key_Return: { QTreeWidgetItem *item = currentItem(); if (item) { item->setExpanded(!item->isExpanded()); } break; } case Qt::Key_Asterisk: { if (modifiers == Qt::ShiftModifier) { // *, by default will expand current item recursively. // We build the tree recursively before the expanding. QTreeWidgetItem *item = currentItem(); if (item) { buildSubTree(item, -1); } } break; } default: break; } VTreeWidget::keyPressEvent(event); }
// Ensure given item is brought to viewport visibility... void qtractorFileListView::ensureVisibleItem ( QTreeWidgetItem *pItem ) { QTreeWidgetItem *pItemAbove = pItem->parent(); if (pItemAbove) { const int iItem = pItemAbove->indexOfChild(pItem); if (iItem > 0) pItemAbove = pItemAbove->child(iItem - 1); } else { const int iItem = QTreeWidget::indexOfTopLevelItem(pItem); if (iItem > 0) { pItemAbove = QTreeWidget::topLevelItem(iItem - 1); if (pItemAbove) { const int iItemCount = pItemAbove->childCount(); if (pItemAbove->isExpanded()) pItemAbove = pItemAbove->child(iItemCount - 1); } } } if (pItemAbove) QTreeWidget::scrollToItem(pItemAbove); QTreeWidget::scrollToItem(pItem); }
// Move the selection within the parameter tuner tree widget void Parametertuner::moveSelection(int dir) { // Error checking if(dir != UP && dir != DOWN) return; // Declare variables QTreeWidgetItem* item; QTreeWidgetItem* tmpItem; QTreeWidgetItem* thisItem; QTreeWidgetItem* parentItem; int itemIndex; // Get the currently selected item thisItem = getSelectedItem(); // If no item is selected then select the first top level item if(!thisItem) { if(dir == DOWN) updateSelection(NULL, m_ui.parameter_root_widget->topLevelItem(0)); else updateSelection(NULL, m_ui.parameter_root_widget->topLevelItem(m_ui.parameter_root_widget->topLevelItemCount() - 1)); return; } // Handle UP case if(dir == UP) { // Go to the previous item in the tree parentItem = itemGetParent(thisItem); itemIndex = parentItem->indexOfChild(thisItem); tmpItem = parentItem->child(itemIndex + UP); if(tmpItem) { item = tmpItem; while(item->childCount() > 0 && item->isExpanded()) item = item->child(item->childCount() - 1); updateSelection(thisItem, item); return; } else if(itemHasParent(thisItem)) { updateSelection(thisItem, parentItem); return; } else return; // <-- This is the case that we are at the very top-most element } // Handle DOWN case if(dir == DOWN) { // If the item has children and is expanded then go to the first child if(thisItem->childCount() > 0 && thisItem->isExpanded()) { updateSelection(thisItem, thisItem->child(0)); return; } // Go to the next item in the tree item = thisItem; while(true) { parentItem = itemGetParent(item); itemIndex = parentItem->indexOfChild(item); tmpItem = parentItem->child(itemIndex + DOWN); if(tmpItem) { updateSelection(thisItem, tmpItem); return; } else { if(itemHasParent(item)) item = parentItem; else return; // <-- This is the case that we are at the very bottom-most element } } } }
void TupItemManager::dropEvent(QDropEvent *event) { bool eventAccept = false; if (event->mimeData()->hasFormat("application/x-dnditemdata")) { QByteArray itemData = event->mimeData()->data("application/x-dnditemdata"); QDataStream dataStream(&itemData, QIODevice::ReadOnly); QPixmap pixmap; QString label; QString extension; QString key; dataStream >> pixmap >> label >> extension >> key; QTreeWidgetItem *item; QTreeWidgetItem *parent = itemAt(event->pos().x(), event->pos().y()); if (parent) { // If both Target and Origin are directories if (parentNode.length() > 0) { if ((parent->text(2).length() == 0) && (extension.length() == 0)) return; } // Ensure Target is a directory if (parent->text(2).length() > 0) return; // Target is going to the same parent int childrenTotal = parent->childCount(); for (int i=0;i < childrenTotal; i++) { QTreeWidgetItem *child = parent->child(i); QString name = child->text(1); if (name.compare(label) == 0 && child->text(2).compare(extension) == 0) return; } // Make sure node and target are not the same if (extension.length() > 0) { if (parentNode.length() > 0) { QList<QTreeWidgetItem *> nodes = findItems(parentNode, Qt::MatchExactly, 1); for (int i = 0; i < nodes.size(); ++i) { QTreeWidgetItem *node = nodes.at(i); if (node->text(1).compare(parentNode) == 0) { int childrenTotal = node->childCount(); for (int i=0;i < childrenTotal; i++) { QTreeWidgetItem *child = node->child(i); if (child->text(1).compare(label) == 0 && child->text(2).compare(extension) == 0) { node->removeChild(child); break; } } break; } } } item = new QTreeWidgetItem(parent); item->setIcon(0, QIcon(pixmap)); item->setText(1, label); item->setText(2, extension); item->setText(3, key); item->setFlags(item->flags() | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled); setCurrentItem(item); if (key.length() > 0) emit itemMoved(key, parent->text(1)); eventAccept = true; } else { bool flag = true; if (parent->isExpanded()) flag = false; parent->setExpanded(flag); } } else { if (parentNode.length() > 0) { QList<QTreeWidgetItem *> nodes = findItems(parentNode, Qt::MatchExactly, 1); for (int i = 0; i < nodes.size(); ++i) { QTreeWidgetItem *node = nodes.at(i); if (node->text(1).compare(parentNode) == 0) { int childrenTotal = node->childCount(); for (int i=0;i < childrenTotal; i++) { QTreeWidgetItem *child = node->child(i); if (child->text(1).compare(label) == 0 && child->text(2).compare(extension) == 0) { node->removeChild(child); break; } } break; } } } else { if (extension.length() == 0 && nodeChildren.size() > 0) return; } item = new QTreeWidgetItem(this); item->setIcon(0, QIcon(pixmap)); item->setText(1, label); item->setText(2, extension); item->setText(3, key); item->setFlags(item->flags() | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled); setCurrentItem(item); emit itemMoved(key, ""); eventAccept = true; } } else {
//----------------------------------------------------------------------------- void resizeColumnsToContents(QTreeWidget* tree, bool includeCollapsedItems) { QList<QTreeWidgetItem*> collapsedItems; // If including collapsed items, first expand the entire tree if (includeCollapsedItems) { for (QTreeWidgetItemIterator iter(tree); *iter; ++iter) { QTreeWidgetItem* item = *iter; if (item->childCount() && !item->isExpanded()) { item->setExpanded(true); collapsedItems.append(item); } } } int i = tree->columnCount(); while (i--) { // Resize to data tree->resizeColumnToContents(i); // Also resize to header, if applicable if (!tree->isHeaderHidden()) { // Get current size int cw = tree->columnWidth(i); // Get header text and icon QString text = tree->headerItem()->text(i); QIcon icon = tree->headerItem()->icon(i); // Get header font, using widget font if unset QFont font = tree->font(); QVariant hfd = tree->headerItem()->data(i, Qt::FontRole); if (hfd.isValid() && hfd.canConvert(QVariant::Font)) { font = hfd.value<QFont>(); } // Calculate size of text and icon QFontMetrics fm(font); int tw = fm.width(text); if (!icon.isNull()) { tw += icon.actualSize(tree->iconSize()).width(); } // Add space for margins and sort indicator tw += 2 * tree->style()->pixelMetric(QStyle::PM_HeaderMargin); tw += 2 * tree->style()->pixelMetric(QStyle::PM_HeaderGripMargin); tw += tree->style()->pixelMetric(QStyle::PM_HeaderMarkSize); // Use header size, if larger if (tw > cw) { tree->setColumnWidth(i, tw); } } } // Restore collapsed state of anything we expanded foreach (QTreeWidgetItem* item, collapsedItems) item->setExpanded(false); }
void TreeWidgetController::reinitialize() { QProgressDialog dlg(tr("Reinitializing view..."), QString(), 0, 3, this); // Perform a BFS and remember the expanded entity items. map<DatabaseEntity::EntityType, set<int> > expandedEntities; queue<QTreeWidgetItem *> q; q.push(invisibleRootItem()); while (!q.empty()) { QTreeWidgetItem *currentItem = q.front(); q.pop(); // Don't bother with non-expanded items. if (currentItem != invisibleRootItem() && !currentItem->isExpanded()) continue; // Enqueue the current item's children. for (int i = 0; i < currentItem->childCount(); i++) q.push(currentItem->child(i)); // Don't bother with non-entity types. if (currentItem->type() != EntityItem::EntityType) continue; EntityItem *entityItem = static_cast<EntityItem *>(currentItem); if (entityItem->type() != DatabaseEntity::Feature) { const int id = getEntityID(entityItem->entityPtr()); set<int> &s = expandedEntities[entityItem->entityPtr()->entityType()]; s.insert(id); } } // Backup the expansion-states of the root items. const bool expandResponses = _rootResponses->isExpanded(); const bool expandLabels = _rootLabels->isExpanded(); const bool expandProcesses = _rootProcesses->isExpanded(); const bool expandClassificationObjects = _rootClassificationObjects->isExpanded(); // Clear the model. if (_rootResponses) invisibleRootItem()->removeChild(_rootResponses); if (_rootLabels) invisibleRootItem()->removeChild(_rootLabels); if (_rootProcesses) invisibleRootItem()->removeChild(_rootProcesses); if (_rootClassificationObjects) invisibleRootItem()->removeChild(_rootClassificationObjects); dlg.setValue(1); // Reload. initializeView(); dlg.setValue(2); // Perform a BFS and reopen the formerly expanded items. q.push(invisibleRootItem()); while (!q.empty()) { QTreeWidgetItem *currentItem = q.front(); q.pop(); // Enqueue the current item's children. for (int i = 0; i < currentItem->childCount(); i++) q.push(currentItem->child(i)); // Don't bother with non-entity types. if (currentItem->type() != EntityItem::EntityType) continue; // Determine the entity's id and reexpand this item if this id is stored // in the entity type's corresponding set of expanded ids. EntityItem *entityItem = static_cast<EntityItem *>(currentItem); const int id = getEntityID(entityItem->entityPtr()); if (id) { set<int> &s = expandedEntities[entityItem->entityPtr()->entityType()]; if (s.find(id) != s.end()) { QTreeWidgetItem *item = entityItem; while (item && item != invisibleRootItem()) { item->setExpanded(true); item = item->parent(); } } } } dlg.setValue(3); // Restore the expansion-states of the root items. if (expandResponses && !_rootResponses->isExpanded()) _rootResponses->setExpanded(true); if (expandLabels && !_rootLabels->isExpanded()) _rootLabels->setExpanded(true); if (expandProcesses && !_rootProcesses->isExpanded()) _rootProcesses->setExpanded(true); if (expandClassificationObjects && !_rootClassificationObjects->isExpanded()) _rootClassificationObjects->setExpanded(true); }
void HierarchyTreeWidget::OnTreeUpdated() { EXPANDEDITEMS expandedItems; EXPANDEDITEMS selectedItems; //save opened node TREEITEMS oldItems = GetAllItems(); for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) { QTreeWidgetItem* item = iter->second; if (item->isExpanded()) { QVariant data = item->data(ITEM_ID); expandedItems.insert(data.toInt()); } } //save selected node for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) { QTreeWidgetItem* item = iter->second; if (item->isSelected()) { QVariant data = item->data(ITEM_ID); selectedItems.insert(data.toInt()); HierarchyTreeNode* baseNode = HierarchyTreeController::Instance()->GetTree().GetNode(data.toInt()); HierarchyTreeControlNode* selectedControl = dynamic_cast<HierarchyTreeControlNode* >(baseNode); if(NULL != selectedControl) { internalSelectionChanged = true; } } } //reset tree ui->treeWidget->clear(); const HierarchyTree& tree = HierarchyTreeController::Instance()->GetTree(); const HierarchyTreeRootNode* rootNode = tree.GetRootNode(); for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = rootNode->GetChildNodes().begin(); iter != rootNode->GetChildNodes().end(); ++iter) { //add platform node const HierarchyTreePlatformNode* platformNode = (const HierarchyTreePlatformNode*)(*iter); QTreeWidgetItem* platformItem = new QTreeWidgetItem(); platformItem->setData(ITEM_ID, platformNode->GetId()); platformItem->setText(0, platformNode->GetName()); platformItem->setIcon(0, QIcon(":/Icons/079i.png")); ui->treeWidget->insertTopLevelItem(ui->treeWidget->topLevelItemCount(), platformItem); for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = platformNode->GetChildNodes().begin(); iter != platformNode->GetChildNodes().end(); ++iter) { const HierarchyTreeScreenNode* screenNode = dynamic_cast<const HierarchyTreeScreenNode*>(*iter); DVASSERT(screenNode); QTreeWidgetItem* screenItem = new QTreeWidgetItem(); screenItem->setData(ITEM_ID, screenNode->GetId()); // Check whether this screen was changed. QString screenItemText = screenNode->GetName(); if (screenNode->GetUnsavedChanges() != 0) { screenItemText += " *"; } screenItem->setText(0, screenItemText); if (dynamic_cast<const HierarchyTreeAggregatorNode*>(screenNode)) screenItem->setIcon(0, QIcon(":/Icons/170.png")); else screenItem->setIcon(0, QIcon(":/Icons/068i.png")); platformItem->insertChild(platformItem->childCount(), screenItem); AddControlItem(screenItem, selectedItems, expandedItems, screenNode->GetChildNodes()); if (expandedItems.find(screenNode->GetId()) != expandedItems.end()) screenItem->setExpanded(true); if (selectedItems.find(screenNode->GetId()) != selectedItems.end()) { screenItem->setSelected(true); } } if (expandedItems.find(platformNode->GetId()) != expandedItems.end()) platformItem->setExpanded(true); if (selectedItems.find(platformNode->GetId()) != selectedItems.end()) { platformItem->setSelected(true); } } internalSelectionChanged = false; }
void HierarchyTreeWidget::OnTreeUpdated(bool needRestoreSelection) { EXPANDEDITEMS expandedItems; EXPANDEDITEMS selectedItems; //save opened node TREEITEMS oldItems = GetAllItems(); for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) { QTreeWidgetItem* item = iter->second; if (item->isExpanded()) { QVariant data = item->data(ITEM_ID); expandedItems.insert(data.toInt()); } } //save selected node for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) { QTreeWidgetItem* item = iter->second; if (item->isSelected()) { QVariant data = item->data(ITEM_ID); selectedItems.insert(data.toInt()); HierarchyTreeNode* baseNode = HierarchyTreeController::Instance()->GetTree().GetNode(data.toInt()); HierarchyTreeControlNode* selectedControl = dynamic_cast<HierarchyTreeControlNode* >(baseNode); if(NULL != selectedControl) { internalSelectionChanged = true; } } } //reset tree ui->treeWidget->clear(); const HierarchyTree& tree = HierarchyTreeController::Instance()->GetTree(); const HierarchyTreeRootNode* rootNode = tree.GetRootNode(); for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = rootNode->GetChildNodes().begin(); iter != rootNode->GetChildNodes().end(); ++iter) { //add platform node const HierarchyTreePlatformNode* platformNode = (const HierarchyTreePlatformNode*)(*iter); QTreeWidgetItem* platformItem = new QTreeWidgetItem(); platformItem->setData(ITEM_ID, platformNode->GetId()); QString platformName = platformNode->GetName(); if (platformNode->IsNeedSave()) { platformName += " *"; } platformItem->setText(0, platformName); platformItem->setIcon(0, QIcon(IconHelper::GetPlatformIconPath())); ui->treeWidget->insertTopLevelItem(ui->treeWidget->topLevelItemCount(), platformItem); for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = platformNode->GetChildNodes().begin(); iter != platformNode->GetChildNodes().end(); ++iter) { const HierarchyTreeScreenNode* screenNode = dynamic_cast<const HierarchyTreeScreenNode*>(*iter); DVASSERT(screenNode); QTreeWidgetItem* screenItem = new QTreeWidgetItem(); screenItem->setData(ITEM_ID, screenNode->GetId()); // Check whether this screen was changed. QString screenItemText = screenNode->GetName(); if (screenNode->IsNeedSave()) { screenItemText += " *"; } screenItem->setText(0, screenItemText); if (dynamic_cast<const HierarchyTreeAggregatorNode*>(screenNode)) screenItem->setIcon(0, QIcon(IconHelper::GetAggregatorIconPath())); else screenItem->setIcon(0, QIcon(IconHelper::GetScreenIconPath())); platformItem->insertChild(platformItem->childCount(), screenItem); AddControlItem(screenItem, screenNode->GetChildNodes()); } } // Restore the selected items only after the tree is fully built. int itemsCount = ui->treeWidget->topLevelItemCount(); for (int i = 0; i < itemsCount; i ++) { QTreeWidgetItem* rootItem = ui->treeWidget->topLevelItem(i); RestoreTreeItemExpandedStateRecursive(rootItem, expandedItems); if (needRestoreSelection) { RestoreTreeItemSelectedStateRecursive(rootItem, selectedItems); } } internalSelectionChanged = false; }