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