QWidget* CarManagePage::CreateStructureWidget()
{
QGroupBox* structureWidget = new QGroupBox();
QHBoxLayout* hBox = new QHBoxLayout();
QToolButton* add = new QToolButton();
add->setText("+");
QToolButton* remove = new QToolButton();
remove->setText( "-" );
hBox->addWidget( add );
hBox->addWidget( remove );
hBox->addStretch( 1 );
QTreeWidget* tree = new QTreeWidget();
tree->setColumnCount( 1 );
QTreeWidgetItem* root = new QTreeWidgetItem( QStringList( tr( "DaQing GPS Center") ) );
QTreeWidgetItem* child1 = new QTreeWidgetItem( QStringList( tr( "test1" ) ) );
QTreeWidgetItem* child2 = new QTreeWidgetItem( QStringList( tr( "test2" ) ) );
root->addChild( child1 );
root->addChild( child2 );
root->setCheckState( 0, Qt::Unchecked );
child1->setCheckState( 0, Qt::Unchecked );
child2->setCheckState( 0, Qt::Unchecked );
tree->addTopLevelItem( root );
tree->expandAll();
QVBoxLayout* vBox = new QVBoxLayout();
vBox->addLayout( hBox );
vBox->addWidget( tree );
structureWidget->setLayout( vBox );
return structureWidget;
}
void SelectiveSyncTreeView::recursiveInsert(QTreeWidgetItem* parent, QStringList pathTrail, QString path)
{
QFileIconProvider prov;
QIcon folderIcon = prov.icon(QFileIconProvider::Folder);
if (pathTrail.size() == 0) {
if (path.endsWith('/')) {
path.chop(1);
}
parent->setToolTip(0, path);
parent->setData(0, Qt::UserRole, path);
} else {
QTreeWidgetItem *item = findFirstChild(parent, pathTrail.first());
if (!item) {
item = new QTreeWidgetItem(parent);
if (parent->checkState(0) == Qt::Checked
|| parent->checkState(0) == Qt::PartiallyChecked) {
item->setCheckState(0, Qt::Checked);
foreach(const QString &str , _oldBlackList) {
if (str == path) {
item->setCheckState(0, Qt::Unchecked);
break;
} else if (str.startsWith(path)) {
item->setCheckState(0, Qt::PartiallyChecked);
}
}
} else if (parent->checkState(0) == Qt::Unchecked) {
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);
}
}
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 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
UserSelectView::slotItemChanged(QTreeWidgetItem* item, int column)
{
if (this->indexOfTopLevelItem(item) != -1)
{
int cnt = item->childCount();
if (item->checkState(0) == Qt::Checked)
{
for (int i = 0; i < cnt; i++)
{
QTreeWidgetItem* chld = item->child(i);
chld->setCheckState(0, Qt::Checked);
}
}
else if (item->checkState(0) == Qt::Unchecked)
{
for (int i = 0; i < cnt; i++)
{
QTreeWidgetItem* chld = item->child(i);
chld->setCheckState(0, Qt::Unchecked);
}
}
}
else
{
QTreeWidgetItem* p = item->parent();
p->setCheckState(0, Qt::PartiallyChecked);
}
}
//向上递归判断
void XMLInfoDialog::updateParentItem(QTreeWidgetItem *item)
{
QTreeWidgetItem* parent = item->parent();
if (parent == NULL)
return;
//选中的子节点个数
int selectedCount = 0;
int childCount = parent->childCount();
for (int i = 0; i < childCount; i++)
{
QTreeWidgetItem* childItem = parent->child(i);
if (childItem->checkState(0) == Qt::Checked)
selectedCount++;
}
if (selectedCount <= 0)
{
parent->setCheckState(0, Qt::Unchecked);//全没选状态
}
else if (selectedCount > 0 && selectedCount < childCount)
{
parent->setCheckState(0, Qt::PartiallyChecked);//设置为部分选中状态
updateParentItem(parent);
}
else if (selectedCount == childCount)
{
parent->setCheckState(0, Qt::Checked);//全选中状态
}
}
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 serverEdit::recieveData(favServer server, QList<addon> addonsList, bool newServer, QStringList names) {
qInfo() << "serverEdit::recieveData: start";
newServ = newServer;
// Настройка сервера
//..при добавлении
if(newServer) {
// Установка параметров сервера
ui->serverName->setText(tr("Новый сервер"));
if(server.serverIP == "...")
ui->serverIP->clear();
else
ui->serverIP->setText(server.serverIP);
ui->serverPort->setText(server.serverPort);
ui->serverPassword->setText(server.serverPass);
ui->name_check->setChecked(false);
// При зименении
} else {
// Установка параметров сервера
ui->serverName->setText(server.serverName);
ui->serverIP->setText(server.serverIP);
ui->serverPort->setText(server.serverPort);
ui->serverPassword->setText(server.serverPass);
ui->name_check->setChecked(server.check_name);
}
// Заполнение списка аддонов
ui->addonTree->clear();
QTreeWidgetItem * item;
for(int i=0; i<addonsList.count();i++) {
// Добавление элемента
item = new QTreeWidgetItem(ui->addonTree);
item->setText(0, addonsList[i].addonName);
item->setText(1, addonsList[i].addonDir);
item->setText(2, addonsList[i].addonPath);
item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled | Qt::ItemIsSelectable);
// Проверка, активен ли этот аддон на сервере
QString fullPath = addonsList[i].addonPath + QString("/") +
addonsList[i].addonDir;
if(server.serverAddons.count()>0) {
// Если содержит, то активируем
if(server.serverAddons.contains(fullPath))
item->setCheckState(0, Qt::Checked);
else // Иначе. деактивируем
item->setCheckState(0, Qt::Unchecked);
} else { // Если у сервера нет подключенных аддонов, то сразу деактивируем
item->setCheckState(0, Qt::Unchecked);
}
}
// Выбранный профиль сервера
ui->name->clear();
ui->name->addItems(names);
ui->name->setCurrentText(server.name);
this->open();
}
SoundPref::SoundPref(QWidget *parent)
: PrefWidget(parent)
{
ui.setupUi(this);
AmeDirs *ame = AmeDirs::global();
stg1 = new AmeSettings(ame->stdDir(AmeDirs::Configs) + "/Sound", QSettings::IniFormat);
readSettings();
// Sound effects tab
ui.soundsLst->setColumnCount(2);
ui.soundsLst->setColumnWidth(0, 420);
QStringList hdr;
hdr << "Name" << "Enabled";
ui.soundsLst->setHeaderLabels(hdr);
Sounds lst = AmeSoundTheme::global()->getAll();
for (int i=0; i<lst.size(); i++) {
QTreeWidgetItem *it = new QTreeWidgetItem(ui.soundsLst);
it->setText(0, lst.at(i)->name);
it->setText(1, "");
if (lst.at(i)->enabled)
it->setCheckState(1, Qt::Checked);
else
it->setCheckState(1, Qt::Unchecked);
it->setData(1, Qt::UserRole, QVariant(lst.at(i)->soundId));
}
connect(ui.soundsLst, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(onSoundItemChange(QTreeWidgetItem *, int)));
connect(ui.soundsLst, SIGNAL(itemActivated(QTreeWidgetItem*, int)), this, SLOT(onSoundItem(QTreeWidgetItem *, int)));
ui.volumeSldr->setMinimum(0);
ui.volumeSldr->setMaximum(100);
connect(ui.volumeSldr, SIGNAL(sliderMoved(int)), this, SLOT(onSlider(int)));
connect(ui.volumeSldr, SIGNAL(sliderReleased()), this, SLOT(onSliderRelease()));
connect(ui.muteChk, SIGNAL(clicked()), this, SLOT(onMute()));
connect(ui.sndVolFeedbackChk, SIGNAL(clicked()),this, SLOT(onVolumeFeedback()));
connect(ui.showCtrlChk, SIGNAL(clicked()), this, SLOT(onShowHideVolumeCtrl()));
timer = new QTimer();
connect(timer, SIGNAL(timeout()), this, SLOT(checkVolume()));
timer->start(100);
// Output settings tab
hwList = new hwDevices();
getHwList(modePlayback);
getMixerDevices(modePlayback);
connect(ui.playbackMixerDeviceCmb, SIGNAL(activated(const QString &)), this, SLOT(onMixerDevice(const QString &)));
refresh();
moduleName = "Sound";
}
void ChannelTreeWidget::addLocalChannel(int ch, const QString &name, bool mute, bool broadcast)
{
QTreeWidgetItem *local = topLevelItem(0);
QTreeWidgetItem *channel = addChannelItem(local, name, CF_BROADCAST);
channel->setData(0, ItemTypeRole, ItemTypeLocalChannel);
channel->setData(0, ChannelIndexRole, ch);
channel->setCheckState(1, mute ? Qt::Checked : Qt::Unchecked);
channel->setCheckState(2, broadcast ? Qt::Checked : Qt::Unchecked);
}
QTreeWidgetItem *ChannelTreeWidget::addChannelItem(QTreeWidgetItem *parent, const QString &text, int flags)
{
QTreeWidgetItem *channel = new QTreeWidgetItem(parent);
channel->setText(0, text);
channel->setCheckState(1, Qt::Unchecked);
if (flags & CF_BROADCAST) {
channel->setCheckState(2, Qt::Unchecked);
}
return channel;
}
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 ImporterWizard::load(ObjImporter::SceneInfo& si)
{
QTreeWidget* t = m_ui->tree;
t->clear();
QList<QTreeWidgetItem*> items;
m_objects = new QTreeWidgetItem(t, QStringList() << "Objects");
m_models = new QTreeWidgetItem(t, QStringList() << "Models");
m_animations = new QTreeWidgetItem(t, QStringList() << "Animations");
m_cameras = new QTreeWidgetItem(t, QStringList() << "Cameras");
m_lights = new QTreeWidgetItem(t, QStringList() << "Lights");
m_materials = new QTreeWidgetItem(t, QStringList() << "Materials");
m_textures = new QTreeWidgetItem(t, QStringList() << "Textures");
items << m_objects << m_models << m_animations << m_cameras << m_lights << m_materials << m_textures;
t->addTopLevelItems(items);
QMap<QString, QString>::const_iterator it;
for (it = si.objects.begin(); it != si.objects.end(); ++it) {
newItem(m_objects, it);
newItem(m_models, it);
}
for (it = si.animations.begin(); it != si.animations.end(); ++it) {
QTreeWidgetItem* x = newItem(m_animations, it);
x->setCheckState(0, Qt::Unchecked);
x->setDisabled(true);
}
for (it = si.cameras.begin(); it != si.cameras.end(); ++it) {
QTreeWidgetItem* x = newItem(m_animations, it);
x->setCheckState(0, Qt::Unchecked);
x->setDisabled(true);
}
for (it = si.lights.begin(); it != si.lights.end(); ++it) {
QTreeWidgetItem* x = newItem(m_lights, it);
x->setCheckState(0, Qt::Unchecked);
x->setDisabled(true);
}
for (it = si.materials.begin(); it != si.materials.end(); ++it) {
newItem(m_materials, it);
}
for (it = si.textures.begin(); it != si.textures.end(); ++it) {
newItem(m_textures, it);
}
foreach (QTreeWidgetItem* i, items) {
i->setFirstColumnSpanned(true);
i->setExpanded(true);
if (i->childCount() == 0) i->setDisabled(true);
}
void FilterSettingsPage::updateAttributes(QListWidgetItem *item)
{
QStringList checkedList;
if (item)
checkedList = m_filterMap.value(item->text());
for (int i = 0; i < m_ui.attributeWidget->topLevelItemCount(); ++i) {
QTreeWidgetItem *itm = m_ui.attributeWidget->topLevelItem(i);
if (checkedList.contains(itm->text(0)))
itm->setCheckState(0, Qt::Checked);
else
itm->setCheckState(0, Qt::Unchecked);
}
}
//void DataMergeGui::addImportList(vector<string>& vec)
void DataMergeGui::addImportList(vector<ImportElement>& vec)
{
vector<ImportElement>::iterator iter;
for (iter = vec.begin(); iter != vec.end(); ++iter)
{
QTreeWidgetItem *topItem = new QTreeWidgetItem(importTree);
string name = iter->fileName;
topItem->setText(0, name.c_str());
topItem->setCheckState(0, Qt::Unchecked);
for (int i = 0; i < iter->bandNum; i++)
{
QTreeWidgetItem *childItem = new QTreeWidgetItem(topItem);
childItem->setCheckState(0, Qt::Unchecked);
childItem->setText(0, tr("Band%1").arg(i + 1));
}
}
/*
vector<string>::iterator iter;
for (iter = vec.begin(); iter != vec.end(); ++iter)
{
QListWidgetItem *item = new QListWidgetItem(importList);
item->setText(iter->c_str());
}
*/
// importTree->setColumnCount(1);
/*
for (int i = 0; i < 4; ++i)
{
QTreeWidgetItem *item = new QTreeWidgetItem(importTree);
item->setText(0, tr("item%1").arg(i));
item->setCheckState(0, Qt::Unchecked);
connect(importTree, SIGNAL(itemClicked(QTreeWidgetItem *, int)),
this, SLOT(treeItemSlot(QTreeWidgetItem *, int)));
items.append(item);
}
for (int t = 0; t < 4; ++t)
{
QTreeWidgetItem *table = new QTreeWidgetItem(items.at(0));
table->setCheckState(0, Qt::Unchecked);
table->setText(0, "Test");
}
importTree->insertTopLevelItems(0, items); */
}
void ListOfTasks::displayTasks() {
listNameLabel->setText(QString(selectedList->getName().c_str()));
tasksTree->clear();
if(this->selectedList->isOrdered()) {
orderedLabel->setText(QString::fromUtf8("Cette liste est ordonnée. Vous devez valider chaque tâche dans l'ordre affiché"));
//orderedLabel->setMinimumSize( 100, 20);
tasksTree->setSortingEnabled(false);
}
else {
orderedLabel->setText("");
tasksTree->setSortingEnabled(true);
tasksTree->sortByColumn(1);
}
gridLayout->addWidget(orderedLabel, 2, 0, 1, 3);
dateLabel->setText(selectedList->getDate()->getReadableDate().c_str());
vector<Task*> tasks = selectedList->getAllTasks();
QTreeWidgetItem* taskItem;
int level = 0;
for(vector<Task*>::iterator it = tasks.begin() ; it != tasks.end() ; it++) {
taskItem = new QTreeWidgetItem(tasksTree);
taskItem = tasksTree->topLevelItem(level);
string taskName = (*it)->getName();
if(this->selectedList->isOrdered()) {
taskName = QString::number(level+1).toStdString() + ". " + taskName;
}
taskItem->setText(0, tr(taskName.c_str()));
taskItem->setText(1, tr((*it)->getDate().c_str()));
if((*it)->isFinished())
taskItem->setCheckState(2, Qt::Checked);
else
taskItem->setCheckState(2, Qt::Unchecked);
level++;
}
mainProgressbar->setValue(selectedList->getProgression());
QObject::connect(tasksTree, SIGNAL(itemChanged(QTreeWidgetItem*,int)), this, SLOT(taskChanged(QTreeWidgetItem*, int)));
}
bool ImportBinary::HandleFile (const QString& filename)
{
QFile file (filename);
if (!file.open (QIODevice::ReadOnly))
{
QMessageBox::critical (this,
tr ("LeechCraft"),
tr ("Could not open file %1 for reading.")
.arg (filename));
return false;
}
QByteArray buffer = qUncompress (file.readAll ());
QDataStream stream (&buffer, QIODevice::ReadOnly);
int magic = 0;
stream >> magic;
if (magic != static_cast<int> (0xd34df00d))
{
QMessageBox::warning (this,
tr ("LeechCraft"),
tr ("Selected file %1 is not a valid "
"LeechCraft::Aggregator exchange file.")
.arg (filename));
return false;
}
int version = 0;
stream >> version;
if (version != 1)
{
QMessageBox::warning (this,
tr ("LeechCraft"),
tr ("Selected file %1 is a valid LeechCraft::Aggregator "
"exchange file, but its version %2 is unknown")
.arg (filename)
.arg (version));
}
QString title, owner, ownerEmail;
stream >> title >> owner >> ownerEmail;
while (stream.status () == QDataStream::Ok)
{
Channel_ptr channel (new Channel (-1, -1));
stream >> (*channel);
Channels_.push_back (channel);
QStringList strings (channel->Title_);
strings << QString::number (channel->Items_.size ());
QTreeWidgetItem *item =
new QTreeWidgetItem (Ui_.FeedsToImport_, strings);
item->setCheckState (0, Qt::Checked);
}
return true;
}
QTreeWidgetItem* TemplKatalogListView::addFlosTemplate( QTreeWidgetItem *parentItem, FloskelTemplate *tmpl )
{
if( ! parentItem ) parentItem = m_root;
QTreeWidgetItem *listItem = new QTreeWidgetItem( parentItem );
slFreshupItem( listItem, tmpl);
tmpl->setListViewItem( listItem );
if( tmpl->calcKind() == CatalogTemplate::ManualPrice )
{
listItem->setIcon(0, KIcon( "kraftdice" ) );
}
else
{
listItem->setIcon(0, SmallIcon("accessories-calculator"));
}
if ( mCheckboxes ) {
listItem->setCheckState(0, Qt::Unchecked);
}
// store the connection between the listviewitem and the template in a dict.
setItemTemplateData(listItem, tmpl);
return listItem;
}
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 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 Filter::show_filters(QTreeWidget *treewidget, QList<filters_struct> values)
{
treewidget->clear();
for (int i = 0; i < values.size(); i++)
{
QTreeWidgetItem *item = new QTreeWidgetItem;
item->setText(0, values.at(i).title.simplified());
item->setFlags(item->flags() | Qt::ItemIsUserCheckable); // добавляем возможность выбора
// и задаём начальное значение
if (values.at(i).is_on)
item->setCheckState(0, Qt::Checked);
else
item->setCheckState(0, Qt::Unchecked);
treewidget->addTopLevelItem(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 msgfrm::loadmsg()
{
QTreeWidgetItem *indexitem = treeindex->currentItem();
initmainlistview(indexitem->text(2));
if(indexitem->text(3) == "10" || indexitem->text(3) == "11" || uid == 0)
{
if(indexitem->text(3) == "11" || uid == 0)
{
btnnew->setEnabled(TRUE);
btnedit->setEnabled(TRUE);
btndelete->setEnabled(TRUE);
btncomplete->setEnabled(TRUE);
}
else
{
btnnew->setEnabled(FALSE);
btndelete->setEnabled(FALSE);
btncomplete->setEnabled(FALSE);
}
QString connstr = QString("SELECT ID, typ, user, date, msgtext, data1, data2, data3, data4, data5 FROM messages WHERE `typ` = '%1' ORDER BY ID DESC;").arg(indexitem->text(2));
QSqlQuery query(connstr);
if(query.isActive())
{
progbar->setMaximum(query.size());
while(query.next())
{
progbar->setValue(query.at()+1);
QTreeWidgetItem *item = new QTreeWidgetItem(treemain);
item->setText(0, query.value(0).toString());
item->setCheckState(1, Qt::Unchecked);
//item->setText(1, query.value(1).toString()); ///////////////////////test
item->setText(2, query.value(2).toString());
QString s = query.value(3).toString();
item->setText(4, s.section("-", 2, 2) + "." + s.section("-", 1, 1) + "." + s.section("-", 0, 0));
item->setText(5, query.value(4).toString());
item->setText(6, query.value(5).toString());
if(indexitem->text(2)=="ord" || indexitem->text(2)=="iem")
item->setText(6, item->text(6).section(" (", 0, 0));
item->setText(7, query.value(6).toString());
item->setText(8, query.value(7).toString());
item->setText(9, query.value(8).toString());
if(indexitem->text(2)=="ord")
{
s = item->text(8);
item->setText(8, s.section("-", 2, 2) + "." + s.section("-", 1, 1) + "." + s.section("-", 0, 0));
s = item->text(9);
item->setText(9, s.section("-", 2, 2) + "." + s.section("-", 1, 1) + "." + s.section("-", 0, 0));
}
if(indexitem->text(2)=="iem")
{
s = item->text(8);
item->setText(8, s.section("-", 2, 2) + "." + s.section("-", 1, 1) + "." + s.section("-", 0, 0));
}
item->setText(10, query.value(9).toString());
}
}
}
}
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
ScanDialog::onFetchTitlesFinished() {
if (mgrt->errorOccurred()) {
resetUI();
return;
}
if (fetchedTitles >= 0) {
QString title;
if (!Scan::title(mgrt->getData(), title))
title = videoLinks[fetchedTitles]; // Fallback to link.
QTreeWidgetItem *item = new QTreeWidgetItem;
item->setCheckState(0, Qt::Unchecked);
item->setText(0, title);
item->setText(1, videoLinks[fetchedTitles]);
itemsTree->addTopLevelItem(item);
updateCount();
progressBar->setValue(++fetchedTitles);
if (fetchedTitles == expectedTitles) {
resetUI();
videoLinks.clear();
mgrt->deleteLater();
Util::appendLog(logEdit, tr("Done."));
return;
}
}
else
fetchedTitles++;
mgrt->fetch(videoLinks[fetchedTitles]);
}
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();
}
QDeleteDataDialog::QDeleteDataDialog(QDataManager* manager,QWidget *parent) :
QDialog(parent),
ui(new Ui::QDeleteDataDialog),
m_listView(new QBaseListView),
m_dataManager(manager)
{
ui->setupUi(this);
ui->verticalLayout->insertWidget(0,m_listView,1);
m_listView->setFrameStyle(QFrame::Box);
m_listView->header()->hide();
QList<QDataGroup*> groups = m_dataManager->getGroups();
foreach(QDataGroup * g,groups)
{
QList<QAbstractDataHost*> datas = g->getDatas();
if(datas.size()>0)
{
QTreeWidgetItem * gitem = new QTreeWidgetItem(m_listView);
gitem->setText(0,g->getGroupName());
gitem->setData(0,DarkRole,true);
gitem->setExpanded(true);
gitem->setIcon(0,m_listView->getExpandIcon());
m_itemToGroup.insert(gitem,g);
foreach(QAbstractDataHost * data,datas)
{
QTreeWidgetItem * ditem = new QTreeWidgetItem(gitem);
ditem->setText(0,data->getPropertyValue("objectName").toString());
ditem->setCheckState(0,Qt::Unchecked);
ditem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
m_itemToData.insert(ditem,data);
}
void Exif::TreeView::reload()
{
clear();
setRootIsDecorated( true );
StringSet keys = Exif::Info::instance()->availableKeys();
QMap<QString, QTreeWidgetItem*> tree;
for( StringSet::const_iterator keysIt = keys.begin(); keysIt != keys.end(); ++keysIt ) {
QStringList subKeys = (*keysIt).split(QLatin1String("."));
QTreeWidgetItem* parent = nullptr;
QString path;
for( QStringList::Iterator subKeyIt = subKeys.begin(); subKeyIt != subKeys.end(); ++subKeyIt ) {
if ( !path.isEmpty() )
path += QString::fromLatin1( "." );
path += *subKeyIt;
if ( tree.contains( path ) )
parent = tree[path];
else {
if ( parent == nullptr )
parent = new QTreeWidgetItem( this, QStringList(*subKeyIt) );
else
parent = new QTreeWidgetItem( parent, QStringList(*subKeyIt) );
parent->setText( 1, path ); // This is simply to make the implementation of selected easier.
parent->setFlags( Qt::ItemIsUserCheckable | Qt::ItemIsEnabled );
parent->setCheckState(0,Qt::Unchecked);
tree.insert( path, parent );
}
}
}
if ( QTreeWidgetItem* item = topLevelItem(0) )
item->setExpanded( true );
}
void VCSliderProperties::levelUpdateChannelSelections()
{
/* Check all items that are present in the slider's list of
controlled channels. We don't need to set other items off,
because this function is run only during init when everything
is off. */
QListIterator <int> it(m_slider->m_levelChannels);
while (it.hasNext() == true)
{
QTreeWidgetItem* fxiNode;
QTreeWidgetItem* chNode;
t_fixture_id fxi_id = KNoID;
t_channel ch = 0;
VCSlider::splitCombinedValue(it.next(), &fxi_id, &ch);
fxiNode = levelFixtureNode(fxi_id);
Q_ASSERT(fxiNode != NULL);
chNode = levelChannelNode(fxiNode, ch);
Q_ASSERT(chNode != NULL);
chNode->setCheckState(KColumnName, Qt::Checked);
}
}
