void XbelTree::parseFolderElement(const QDomElement &element, QTreeWidgetItem *parentItem) { QTreeWidgetItem *item = createItem(element, parentItem); QString title = element.attribute("title"); QString value_ergo = element.attribute("value_ergo"); QString value_ves = element.attribute("value_ves"); QString value_number = element.attribute("value_number"); QString foldedString = element.attribute("folded"); item->setFlags(item->flags() | Qt::ItemIsEditable); item->setIcon(0, folderIcon); item->setText(0, title); item->setText(1, value_ergo); item->setText(2, value_ves); item->setText(3, value_number); item->setText(4, foldedString); bool folded = (element.attribute("folded") != "no"); setItemExpanded(item, !folded); QDomElement child = element.firstChildElement(); while (!child.isNull()) { if (child.tagName() == "folder") { parseFolderElement(child, item); } else if (child.tagName() == "separator") { QTreeWidgetItem *childItem = createItem(child, item); childItem->setFlags(item->flags() & ~(Qt::ItemIsSelectable | Qt::ItemIsEditable)); childItem->setText(0, QString(30, 0xB7)); } child = child.nextSiblingElement(); } }
void DataSelectionScreen::addItem(QString name) { if (name.contains(":")) { QString sysid = name.mid(0,name.indexOf(":")); name = name.mid(name.indexOf(":")+1); m_nameToSysId[name] = sysid; } if (name.contains(".")) { //It's a split name, "GCS Status.Roll" for instance. QString shortname = name.split(".")[1]; QString groupname = name.split(".")[0]; QList<QTreeWidgetItem*> findlist = ui.treeWidget->findItems(groupname,Qt::MatchContains); if (findlist.size() > 0) { QTreeWidgetItem *child = new QTreeWidgetItem(QStringList() << shortname); child->setFlags(child->flags() | Qt::ItemIsUserCheckable); child->setCheckState(0,Qt::Unchecked); findlist[0]->addChild(child); } else { QTreeWidgetItem *item = new QTreeWidgetItem(QStringList() << groupname); ui.treeWidget->addTopLevelItem(item); QTreeWidgetItem *child = new QTreeWidgetItem(QStringList() << shortname); child->setFlags(child->flags() | Qt::ItemIsUserCheckable); child->setCheckState(0,Qt::Unchecked); item->addChild(child); } } ui.treeWidget->sortByColumn(0,Qt::AscendingOrder); }
void TupItemManager::createFolder(const QString &name) { if (name.isNull()) folderName = tr("New folder %1").arg(foldersTotal); else folderName = name; QTreeWidgetItem *newFolder = new QTreeWidgetItem(this); newFolder->setFlags(newFolder->flags() | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled); newFolder->setIcon(0, QIcon(THEME_DIR + "icons/open.png")); newFolder->setText(1, folderName); newFolder->setText(2, ""); newFolder->setFlags(newFolder->flags() | Qt::ItemIsEditable); foldersTotal++; m_currentFolder = newFolder; setCurrentItem(m_currentFolder); if (name.isNull()) { editItem(m_currentFolder, 1); emit itemCreated(newFolder); } }
void AccountTreeWidget::dragEnterEvent( QDragEnterEvent *event ) { if ( event->source() == this && (event->proposedAction() == Qt::MoveAction || dragDropMode() == QAbstractItemView::InternalMove) ) { QList<QTreeWidgetItem*> items = selectedItems(); if( items.size() != 1 ) return; bool dragingIdentity = !dynamic_cast<KopeteAccountLVI*>(items.first()); // Set drop flag based on item we drag if ( dragingIdentity ) invisibleRootItem()->setFlags(invisibleRootItem()->flags() | Qt::ItemIsDropEnabled); else invisibleRootItem()->setFlags(invisibleRootItem()->flags() & ~Qt::ItemIsDropEnabled); for ( int i = 0; i < this->topLevelItemCount(); i++ ) { QTreeWidgetItem* identityItem = this->topLevelItem( i ); if ( dragingIdentity ) identityItem->setFlags( identityItem->flags() & ~Qt::ItemIsDropEnabled ); else identityItem->setFlags( identityItem->flags() | Qt::ItemIsDropEnabled ); } QTreeWidget::dragEnterEvent(event); } }
void QgsGlobePluginDialog::readProjectSettings() { // Imagery settings mImageryTreeView->clear(); for ( const LayerDataSource &ds : getImageryDataSources() ) { QTreeWidgetItem *item = new QTreeWidgetItem( QStringList() << ds.type << ds.uri ); item->setFlags( item->flags() & ~Qt::ItemIsDropEnabled ); mImageryTreeView->addTopLevelItem( item ); } mImageryTreeView->resizeColumnToContents( 0 ); // Elevation settings mElevationTreeView->clear(); for ( const LayerDataSource &ds : getElevationDataSources() ) { QTreeWidgetItem *item = new QTreeWidgetItem( QStringList() << ds.type << ds.uri ); item->setFlags( item->flags() & ~Qt::ItemIsDropEnabled ); mElevationTreeView->addTopLevelItem( item ); } mElevationTreeView->resizeColumnToContents( 0 ); #if OSGEARTH_VERSION_GREATER_OR_EQUAL( 2, 5, 0 ) mSpinBoxVerticalScale->setValue( QgsProject::instance()->readDoubleEntry( "Globe-Plugin", "/verticalScale", 1 ) ); #endif // Map settings groupBoxSky->setChecked( QgsProject::instance()->readBoolEntry( "Globe-Plugin", "/skyEnabled", true ) ); checkBoxDateTime->setChecked( QgsProject::instance()->readBoolEntry( "Globe-Plugin", "/overrideDateTime", false ) ); dateTimeEditSky->setDateTime( QDateTime::fromString( QgsProject::instance()->readEntry( "Globe-Plugin", "/skyDateTime", QDateTime::currentDateTime().toString() ) ) ); checkBoxSkyAutoAmbient->setChecked( QgsProject::instance()->readBoolEntry( "Globe-Plugin", "/skyAutoAmbient", false ) ); horizontalSliderMinAmbient->setValue( QgsProject::instance()->readDoubleEntry( "Globe-Plugin", "/skyMinAmbient", 30. ) ); }
void QCustomTreeWidget::keyReleaseEvent(QKeyEvent *e) { QTreeWidgetItem *qItem = currentItem(); if (qItem != NULL) { switch (e->key()) { case Qt::Key_F2: qItem->setFlags(qItem->flags() | Qt::ItemIsEditable); editItem(qItem); bEditing = true; qItem->setFlags(qItem->flags() & ~Qt::ItemIsEditable); break; case Qt::Key_Delete: if (!bEditing) { deleteItem(qItem); } break; case Qt::Key_Plus: if (!bEditing) { addItem(dynamic_cast<QCustomTreeWidgetItem*>(qItem)); } break; case Qt::Key_Space: if (!bEditing) { launchItem(qItem); } break; case Qt::Key_Return: case Qt::Key_Enter: case Qt::Key_Escape: bEditing = false; break; default: QTreeWidget::keyReleaseEvent(e); break; } } }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QTreeWidgetItem* FilterLibraryTreeWidget::UnwrapTreeItem(QJsonObject object) { FilterLibraryTreeWidget::ItemType type = FilterLibraryTreeWidget::ItemType(object["Type"].toInt()); QTreeWidgetItem* item = new QTreeWidgetItem(type); QString name = object["Name"].toString(); item->setText(0, name); item->setData(0, Qt::UserRole, name); if (type == FilterLibraryTreeWidget::Node_Item_Type) { item->setIcon(0, QIcon(":/folder_blue.png")); item->setFlags(item->flags() | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled); item->setData(2, Qt::UserRole, object["Expanded"].toBool()); for (QJsonObject::iterator iter = object.begin(); iter != object.end(); ++iter) { if (iter.value().isObject()) { QJsonObject childObj = iter.value().toObject(); QTreeWidgetItem* child = FilterLibraryTreeWidget::UnwrapTreeItem(childObj); item->insertChild(0, child); } } } else { item->setIcon(0, QIcon(":/text.png")); item->setFlags(item->flags() | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled); item->setText(1, object["Path"].toString()); item->setData(1, Qt::UserRole, object["Path"].toString()); } return item; }
void XMLParameterReader::read_subsection_element(QTreeWidgetItem *parent) { // The structure of the parameter file is assumed to be of the form // // <subsection> // <subsection> // ... // <parameter> // <value> ... </value> // ... // <pattern_description> ... </pattern_description> // </parameter> // <parameter> // ... // </parameter> // ... // </subsection> // <subsection> // ... // </subsection> // ... // </subsection> // // Any subsection has a user-specified name also any parameter, but we do not know // the userspecified names and we can not assume anything. So, when parsing the file, // we do not know, if the actual <start_element> is a <subsection> or a <parameter> // in a subsection. To decide, if the element is a subsection- or a parameter-name, // we assume, that if the next <start_element> is <value>, we have a <parameter> // and a parameter has the entries <value>, <default_value>, <documentation>, // <pattern> and <pattern_description> Q_ASSERT(xml.isStartElement()); // the actual element is <subsection> QTreeWidgetItem * subsection = create_child_item(parent); // create a new subsection in the tree subsection->setIcon(0, subsection_icon); // set the icon, subsection->setText(0, demangle(xml.name().toString())); // the name tree_widget->setItemExpanded(subsection, 0); // and the folder is not expanded while (xml.readNext() != QXmlStreamReader::Invalid) // read the next element { if (xml.isEndElement()) // if the next element is </subsection>, break the loop break; if (xml.isStartElement()) // if it is a start element { if (xml.name() == "value") // it can be <value>, then we have found a parameter, { subsection->setFlags(subsection->flags() | Qt::ItemIsEditable); // values can be edited, read_parameter_element (subsection); } else // or it can be a new <subsection> { subsection->setFlags(subsection->flags() | Qt::NoItemFlags); // subsections can not be edited, read_subsection_element (subsection); }; }; }; }
void BookmarksSideBar::addFolder(const QString &name) { QTreeWidgetItem* item = new QTreeWidgetItem(ui->bookmarksTree); item->setText(0, name); item->setIcon(0, style()->standardIcon(QStyle::SP_DirIcon)); if (name != _bookmarksToolbar && name != _bookmarksMenu) { item->setFlags(item->flags() | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled); } else { item->setFlags((item->flags() & ~Qt::ItemIsDragEnabled) | Qt::ItemIsDropEnabled); } }
ReportFilter::ReportFilter(QVector<QString> objects) { mDialog = new QDialog(); mVbox = new QVBoxLayout(); mDialog->setWindowTitle(tr("Report Filter")); mLabel = new QLabel("Please select the objects and categories to be presented in report"); mTreeWidget = new QTreeWidget(); QStringList ColumnNames; ColumnNames << "Object"; mTreeWidget->setHeaderLabels(ColumnNames); mObject = objects; for (int i = 0; i < objects.size(); i++) { QTreeWidgetItem *item = new QTreeWidgetItem(); item->setText(0, QString(objects[i])); item->setFlags(item->flags() | Qt::ItemIsUserCheckable); item->setCheckState(0, Qt::Unchecked); for (int j = 0; j < 11; j++) { QTreeWidgetItem *child = new QTreeWidgetItem(); child->setText(0, QString(num2category(j).c_str())); child->setFlags(child->flags() | Qt::ItemIsUserCheckable); child->setCheckState(0, Qt::Unchecked); item->addChild(child); } mItems.push_back(item); } mTreeWidget->insertTopLevelItems(0, mItems); connect(mTreeWidget, SIGNAL(itemChanged(QTreeWidgetItem* , int)), this, SLOT(itemChanged(QTreeWidgetItem* , int))); mButtonGridBox = new QGridLayout(); mGenerateButton = new QPushButton("Generate"); connect(mGenerateButton, SIGNAL(clicked()), this, SLOT(generate())); mCancelButton = new QPushButton("Cancel"); connect(mCancelButton, SIGNAL(clicked()), this, SLOT(cancel())); mSelectAllButton = new QPushButton("Select All"); connect(mSelectAllButton, SIGNAL(clicked()), this, SLOT(selectAll())); mButtonGridBox->addWidget(mSelectAllButton, 0, 4, 1, 1, Qt::AlignVCenter | Qt::AlignLeft); mButtonGridBox->addWidget(mGenerateButton, 0, 4, 1, 3, Qt::AlignVCenter | Qt::AlignRight); mButtonGridBox->addWidget(mCancelButton, 0, 4, 1, 4, Qt::AlignVCenter | Qt::AlignRight); mVbox->addWidget(mLabel); mVbox->addWidget(mTreeWidget); mVbox->addLayout(mButtonGridBox); mDialog->setMinimumWidth(250); mDialog->setLayout(mVbox); isGenerate = false; }
void MetadataListView::setCurrentItemByKey(const QString& itemKey) { if (itemKey.isNull()) { return; } int i = 0; QTreeWidgetItem* item = 0; do { item = topLevelItem(i); if (item && (item->flags() & Qt::ItemIsSelectable)) { MetadataListViewItem* lvItem = dynamic_cast<MetadataListViewItem*>(item); if (lvItem) { if (lvItem->getKey() == itemKey) { setCurrentItem(item); scrollToItem(item); m_selectedItemKey = itemKey; return; } } } ++i; } while (item); }
void PlanSimSubpanel::onSimulationFinished() { bool oldBlockTree = right->ui->treeSimViews->blockSignals(true); right->ui->treeSimViews->clear(); onTimeout(); timer.stop(); if (sim_process and not sim_process->error_simu.isEmpty()) { mLog->logExt(sim_process->error_simu, true); } else if (sim_process and sim_process->output_map) { const vle::value::Map& simu = *sim_process->output_map; QList<QTreeWidgetItem*> views_items; vle::value::Map::const_iterator itb = simu.begin(); vle::value::Map::const_iterator ite = simu.end(); for (; itb != ite; itb++) { QString viewName(itb->first.c_str()); QStringList viewType = mvpz->getViewTypeFromDoc(viewName); if (viewType.contains("finish")) { QTreeWidgetItem* vItem = new QTreeWidgetItem(); vItem->setText( 0, QString("%1 (%2)").arg(viewName).arg("finish")); vItem->setData(0, Qt::UserRole + 0, "view"); vItem->setData(0, Qt::UserRole + 1, viewName); const vle::value::Matrix& res = itb->second->toMatrix(); for (unsigned int i = 0; i < res.columns(); i++) { if (res.get(i, 0) and res.get(i, 0)->isString()) { QString portName = res.getString(i, 0).c_str(); if (portName.contains("AchievedPlan")) { QTreeWidgetItem* pItem = new QTreeWidgetItem(); pItem->setText(0, portName); pItem->setFlags(vItem->flags() | Qt::ItemIsUserCheckable); pItem->setCheckState(0, Qt::Unchecked); pItem->setData(0, Qt::UserRole + 0, "port"); pItem->setData(0, Qt::UserRole + 1, viewName); pItem->setData(0, Qt::UserRole + 2, portName); vItem->addChild(pItem); } } } views_items.append(vItem); } } right->ui->treeSimViews->addTopLevelItems(views_items); } updateCustomPlot(); right->ui->treeSimViews->blockSignals(oldBlockTree); thread->quit(); thread->wait(); delete thread; thread = 0; left->ui->runButton->setEnabled(true); }
void autobots_toutiao::AddToTree(const QString& text) { QTreeWidgetItem* item = new QTreeWidgetItem(ui.treeWidget_comment_id); item->setText(0,text); item->setFlags(item->flags() | Qt::ItemIsEditable); ui.treeWidget_comment_id->addTopLevelItem(item); }
DialogPreferences::DialogPreferences(boost::shared_ptr<SettingsManagerBase> settings_, QWidget* parent) : QDialog(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint) , settings(settings_) { this->setupUi(this); delete checkAutoClear; delete timeEdit; delete horizontalLayout_5; delete checkBox_6; scanWidgets(this); listAdvancedOptions->setItemDelegate(new ItemDelegateEditCollumn(listAdvancedOptions, CN_CURVALUE)); std::vector<std::string> keys = settings->getAllKeys(); BOOST_FOREACH(const std::string& s, keys) { if (widgets.count(s) == 0) { QTreeWidgetItem* twi = new QTreeWidgetItem(listAdvancedOptions); twi->setText(CN_KEY, S2Q(s)); twi->setText(CN_DEFAULT, S2Q(settings->getInfo(s)->getDefault())); twi->setFlags(twi->flags() | Qt::ItemIsEditable); } } listCategories->setCurrentRow(0); SettingsVariableBase* sv = settings->getVariable("gui.qt.showadvancedsettings"); bool showadvanced = sv->getValue<bool>(); if (!showadvanced) delete listCategories->item(listCategories->count()-1); initSettings(); }
void VCSliderProperties::levelUpdateChannelNode(QTreeWidgetItem* parent, Fixture* fxi, t_channel ch) { QTreeWidgetItem* item; const QLCChannel* channel; QString str; Q_ASSERT(parent != NULL); channel = fxi->channel(ch); Q_ASSERT(channel != NULL); item = levelChannelNode(parent, ch); if (item == NULL) { item = new QTreeWidgetItem(parent); item->setText(KColumnID, str.setNum(ch)); item->setFlags(item->flags() | Qt::ItemIsUserCheckable); item->setCheckState(KColumnName, Qt::Unchecked); } item->setText(KColumnName, channel->name()); item->setText(KColumnType, channel->group()); levelUpdateCapabilities(item, channel); }
RsCollectionDialog::RsCollectionDialog(const QString& CollectionFileName,const std::vector<RsCollectionFile::DLinfo>& dlinfos) : _dlinfos(dlinfos),_filename(CollectionFileName) { setupUi(this) ; setWindowFlags(Qt::Window); // for maximize button setWindowFlags(windowFlags() & ~Qt::WindowMinimizeButtonHint); setWindowTitle(QString("%1 - %2").arg(windowTitle()).arg(QFileInfo(_filename).completeBaseName())); // 1 - add all elements to the list. _fileEntriesTW->setColumnCount(3) ; QTreeWidgetItem *headerItem = _fileEntriesTW->headerItem(); headerItem->setText(0, tr("File")); headerItem->setText(1, tr("Size")); headerItem->setText(2, tr("Hash")); uint32_t size = dlinfos.size(); uint64_t total_size ; uint32_t total_files ; for(uint32_t i=0;i<size;++i) { const RsCollectionFile::DLinfo &dlinfo = dlinfos[i]; QTreeWidgetItem *item = new QTreeWidgetItem; item->setFlags(Qt::ItemIsUserCheckable | item->flags()); item->setCheckState(0, Qt::Checked); item->setData(0, Qt::UserRole, i); item->setText(0, dlinfo.path + "/" + dlinfo.name); item->setText(1, misc::friendlyUnit(dlinfo.size)); item->setText(2, dlinfo.hash); _fileEntriesTW->addTopLevelItem(item); total_size += dlinfo.size ; total_files++ ; } _filename_TL->setText(_filename) ; for (int column = 0; column < _fileEntriesTW->columnCount(); ++column) { _fileEntriesTW->resizeColumnToContents(column); } updateSizes() ; // 2 - connect necessary signals/slots connectUpdate(true); connect(_selectAll_PB,SIGNAL(clicked()),this,SLOT(selectAll())) ; connect(_deselectAll_PB,SIGNAL(clicked()),this,SLOT(deselectAll())) ; connect(_cancel_PB,SIGNAL(clicked()),this,SLOT(cancel())) ; connect(_download_PB,SIGNAL(clicked()),this,SLOT(download())) ; _fileEntriesTW->installEventFilter(this); }
void EFXEditor::addFixtureItem(EFXFixture* ef) { QTreeWidgetItem* item; Fixture* fxi; Q_ASSERT(ef != NULL); fxi = m_doc->fixture(ef->fixture()); if (fxi == NULL) return; item = new QTreeWidgetItem(m_tree); item->setText(KColumnName, fxi->name()); item->setData(0, Qt::UserRole, QVariant(reinterpret_cast<qulonglong> (ef))); item->setFlags(item->flags() | Qt::ItemIsUserCheckable); if (ef->direction() == Function::Backward) item->setCheckState(KColumnReverse, Qt::Checked); else item->setCheckState(KColumnReverse, Qt::Unchecked); updateIntensityColumn(item, ef); updateStartOffsetColumn(item, ef); updateIndices(m_tree->indexOfTopLevelItem(item), m_tree->topLevelItemCount() - 1); /* Select newly-added fixtures so that they can be moved quickly */ m_tree->setCurrentItem(item); redrawPreview(); }
void moveDownClicked() { QList<QTreeWidgetItem*> selectedPaths = m_treeView->selectedItems(); if( selectedPaths.isEmpty() ) { return; } else if( m_treeView->indexOfTopLevelItem(selectedPaths.last()) == m_treeView->topLevelItemCount() -1) { return; } else { // Retrieves the value that is before the first selected row. int index = m_treeView->indexOfTopLevelItem( selectedPaths.last() ); QTreeWidgetItem* newRow = m_treeView->takeTopLevelItem(index); newRow->setFlags(newRow->flags() | Qt::ItemIsEditable); m_treeView->insertTopLevelItem( index + 1, newRow); newRow->setSelected(true); m_treeView->topLevelItem(index)->setSelected(false); rebuildRowIndexes(); // Sends a change notification. Q_EMIT signalChanged(); } }
void QgsGlobePluginDialog::addElevation( const QString &type, const QString &uri ) { QTreeWidgetItem *item = new QTreeWidgetItem( QStringList() << type << uri ); item->setFlags( item->flags() & ~Qt::ItemIsDropEnabled ); mElevationTreeView->addTopLevelItem( item ); mElevationTreeView->resizeColumnToContents( 0 ); }
QTreeWidgetItem *QgsSettingsTree::createItem( const QString &text, QTreeWidgetItem *parent, int index ) { QTreeWidgetItem *after = 0; if ( index != 0 ) after = childAt( parent, index - 1 ); QTreeWidgetItem *item; if ( parent ) item = new QTreeWidgetItem( parent, after ); else item = new QTreeWidgetItem( this, after ); item->setText( 0, text ); item->setFlags( item->flags() | Qt::ItemIsEditable ); QString key = itemKey( item ); QgsDebugMsg( key ); if ( settingsMap.contains( key ) ) { QgsDebugMsg( "contains!!!!" ); QStringList values = settingsMap[ key ]; item->setText( 3, values.at( 0 ) ); item->setToolTip( 0, values.at( 1 ) ); item->setToolTip( 2, values.at( 1 ) ); } // if ( settingsMap.contains( return item; }
foreach(sqlb::FieldPtr f, fields) { QTreeWidgetItem *tbitem = new QTreeWidgetItem(ui->treeWidget); tbitem->setFlags(tbitem->flags() | Qt::ItemIsEditable); tbitem->setText(kName, f->name()); QComboBox* typeBox = new QComboBox(ui->treeWidget); typeBox->setProperty("column", f->name()); typeBox->setEditable(false); typeBox->addItems(sqlb::Field::Datatypes); int index = typeBox->findText(f->type(), Qt::MatchExactly); if(index == -1) { // non standard named type typeBox->addItem(f->type()); index = typeBox->count() - 1; } typeBox->setCurrentIndex(index); connect(typeBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateTypes())); ui->treeWidget->setItemWidget(tbitem, kType, typeBox); tbitem->setCheckState(kNotNull, f->notnull() ? Qt::Checked : Qt::Unchecked); tbitem->setCheckState(kPrimaryKey, f->primaryKey() ? Qt::Checked : Qt::Unchecked); tbitem->setCheckState(kAutoIncrement, f->autoIncrement() ? Qt::Checked : Qt::Unchecked); tbitem->setCheckState(kUnique, f->unique() ? Qt::Checked : Qt::Unchecked); tbitem->setText(kDefault, f->defaultValue()); tbitem->setText(kCheck, f->check()); ui->treeWidget->addTopLevelItem(tbitem); }
void ConfigureArtNet::fillOutputTree() { m_outputTree->header()->setResizeMode(QHeaderView::ResizeToContents); QList<QNetworkAddressEntry> ifaces = m_plugin->interfaces(); QList<ArtNetIO> IOmap = m_plugin->getIOMapping(); foreach (QNetworkAddressEntry entry, ifaces) { QString ifaceStr = entry.ip().toString(); for (int u = 0; u < UNIVERSES_PER_ADDRESS; u++) { QTreeWidgetItem* pitem = new QTreeWidgetItem(m_outputTree); pitem->setFlags(pitem->flags() | Qt::ItemIsUserCheckable); pitem->setCheckState(KOutputColumnNetwork, Qt::Unchecked); for (int idx = 0; idx < IOmap.length(); idx++) { if (IOmap.at(idx).IPAddress == ifaceStr && IOmap.at(idx).port == u) { pitem->setCheckState(KOutputColumnNetwork, Qt::Checked); break; } } pitem->setText(KOutputColumnNetwork, ifaceStr); pitem->setText(KOutputColumnUniverse, tr("Universe %1").arg(u)); pitem->setData(KOutputColumnUniverse, Qt::UserRole, u); } }
void QtBlockListEditorWindow::handleItemChanged(QTreeWidgetItem *item, int) { // check whether changed item contains a valid JID and make it removable if (item && item->text(0) != freshBlockListTemplate) { item->setText(1, ""); } // check for empty rows and add an empty one so the user can add items bool hasEmptyRow = false; for( int i = 0; i < ui->blockListTreeWidget->topLevelItemCount(); ++i ) { QTreeWidgetItem* row = ui->blockListTreeWidget->topLevelItem(i); if (row->text(0) == freshBlockListTemplate) { hasEmptyRow = true; } else if (row->text(0).isEmpty()) { ui->blockListTreeWidget->removeItemWidget(row, 0); } } if (!hasEmptyRow) { QTreeWidgetItem* item = new QTreeWidgetItem(QStringList(freshBlockListTemplate) << "x"); item->setFlags(item->flags() | Qt::ItemIsEditable); ui->blockListTreeWidget->addTopLevelItem(item); } if (!item) { ui->blockListTreeWidget->setCurrentItem(ui->blockListTreeWidget->topLevelItem(0)); } }
void KbOptionsWidget::fillTree(KeyboardSettings ks) { QMap<QString, QTreeWidgetItem*> grpRoot; QStringList grps = possibleOptionGroups(); for(int i=0; i<grps.size(); i++) { //create group root QString grp_id = grps[i]; QTreeWidgetItem* parrent = new QTreeWidgetItem(); parrent->setText(0,optionGroupDescription(grp_id)); ui->optionsTW->addTopLevelItem(parrent); //add options QStringList opts = possibleOptions(grp_id); for (int j=0; j<opts.size(); j++) { QString opt_id = opts[j]; QString opt_descr = optionDescription(grp_id, opt_id); QTreeWidgetItem* option = new QTreeWidgetItem(); option->setText(0, opt_descr); option->setFlags(option->flags() | Qt::ItemIsUserCheckable | Qt::ItemIsSelectable); option->setCheckState(0,(ks.hasOption(Option(grp_id, opt_id)))?Qt::Checked:Qt::Unchecked); QVariant udata; udata.setValue(Option(grp_id, opt_id)); option->setData(0, Qt::UserRole, udata); parrent->addChild(option); } } }
void SkladView::add(ShopItem *pItem, const bool isNew) { QTreeWidgetItem* pTreeItem = new QTreeWidgetItem(); pTreeItem->setText(sklad_view_num, "---"); pTreeItem->setText(sklad_view_code, pItem->code); pTreeItem->setText(sklad_view_name, pItem->name); pTreeItem->setText(sklad_view_count, QString::number(pItem->count)); pTreeItem->setText(sklad_view_sell_price, QString::number(pItem->selling_price)); pTreeItem->setText(sklad_view_buy_price, QString::number(pItem->buying_price)); pTreeItem->setText(sklad_view_discont, QString::number(pItem->discont)); pTreeItem->setText(sklad_view_bonus, QString::number(pItem->bonus)); pTreeItem->setText(sklad_view_bonus_pay, ShopState::flagToString(pItem->flags & si_flag_cant_pay_bonus)); pTreeItem->setText(sklad_view_free_price, ShopState::flagToString(pItem->flags & si_flag_free_price)); float finalPrice = pItem->selling_price*(1. - 0.01*pItem->discont); pTreeItem->setText(sklad_view_final_price, QString::number(finalPrice)); pTreeItem->setData(sklad_view_num, sklad_view_role_item, QVariant::fromValue((void*)pItem)); pTreeItem->setData(sklad_view_num, sklad_view_role_state, isNew ? sklad_view_new_item : sklad_view_exs_item); pTreeItem->setFlags(pTreeItem->flags() | Qt::ItemIsEditable); if(isNew){ for(int n = 0; n < sklad_view_total; ++n) pTreeItem->setBackgroundColor(n, QColor(200, 255, 200, 255)); } else{ pTreeItem->setText(sklad_view_added, pItem->added.toString()); pTreeItem->setText(sklad_view_last_change, pItem->changed.toString()); } ui->view->addTopLevelItem(pTreeItem); }
void PropertySelectionTreeWidget::addProcessorNetwork(ProcessorNetwork* processorNetwork, std::string workspaceFileName) { std::vector<Processor*> processors = processorNetwork->getProcessors(); QTreeWidgetItem* worksapceItem = new QTreeWidgetItem(QStringList(QString::fromStdString(workspaceFileName))); if (processors.size()) propertySelectionTree_->addTopLevelItem(worksapceItem); else { LogWarn("Empty workpace with no processors" << workspaceFileName); return; } for (auto& processor : processors) { std::vector<Property*> properties = processor->getProperties(); std::string processorId = processor->getIdentifier(); QTreeWidgetItem* processorItem = new QTreeWidgetItem(QStringList(QString::fromStdString(processorId))); worksapceItem->addChild(processorItem); for (auto& propertie : properties) { std::string id = propertie->getIdentifier(); QTreeWidgetItem* newItem = new QTreeWidgetItem(QStringList(QString::fromStdString(id))); processorItem->addChild(newItem); newItem->setFlags(newItem->flags() | Qt::ItemIsUserCheckable); newItem->setCheckState(0, Qt::Unchecked); } propertySelectionTree_->addTopLevelItem(processorItem); processorItem->sortChildren(0, Qt::AscendingOrder); } propertySelectionTree_->expandAll(); }
void ColoringRulesDialog::addColoringRule(bool disabled, QString name, QString filter, QColor foreground, QColor background, bool start_editing, bool at_top) { QTreeWidgetItem *ti = new QTreeWidgetItem(); ti->setFlags(ti->flags() | Qt::ItemIsUserCheckable | Qt::ItemIsEditable); ti->setFlags(ti->flags() & ~(Qt::ItemIsDropEnabled)); ti->setCheckState(name_col_, disabled ? Qt::Unchecked : Qt::Checked); ti->setText(name_col_, name); ti->setText(filter_col_, filter); for (int i = 0; i < ui->coloringRulesTreeWidget->columnCount(); i++) { ti->setForeground(i, foreground); ti->setBackground(i, background); } if (at_top) { ui->coloringRulesTreeWidget->insertTopLevelItem(0, ti); } else { ui->coloringRulesTreeWidget->addTopLevelItem(ti); } if (start_editing) { ui->coloringRulesTreeWidget->setCurrentItem(ti); updateWidgets(); ui->coloringRulesTreeWidget->editItem(ti, filter_col_); } }
void AdBlockTreeWidget::addRule() { if (!m_subscription->canEditRules()) { return; } QString newRule = QInputDialog::getText(this, tr("Add Custom Rule"), tr("Please write your rule here:")); if (newRule.isEmpty()) { return; } AdBlockRule* rule = new AdBlockRule(newRule, m_subscription); int offset = m_subscription->addRule(rule); QTreeWidgetItem* item = new QTreeWidgetItem(); item->setText(0, newRule); item->setData(0, Qt::UserRole + 10, offset); item->setFlags(item->flags() | Qt::ItemIsEditable); m_itemChangingBlock = true; m_topItem->addChild(item); m_itemChangingBlock = false; adjustItemFeatures(item, rule); }
bool XbelTree::slot_insertItem(bool child) { QDomElement root = domDocument.documentElement(); QList<QTreeWidgetItem *> list; list = XbelTree::selectedItems(); if(list.isEmpty()) { QMessageBox::about(this,tr("Предупреждение"),tr("Не выбран элемент для определения места вставки")); return false; } if(!child) list[0] = list[0]->parent(); QTreeWidgetItem *item = createItem(root,list[0]); QString title = QObject::tr("Folder"); item->setFlags(item->flags() | Qt::ItemIsEditable); item->setIcon(0, folderIcon); item->setText(0, title); item->setText(1, tr("value")); item->setText(2, tr("value")); item->setText(3, tr("value")); item->setText(4, tr("no")); return true; }
int QTreeWidgetItemProto::flags() const { QTreeWidgetItem *item = qscriptvalue_cast<QTreeWidgetItem*>(thisObject()); if (item) return item->flags(); return 0; }