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;
}
