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 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 SettingsEditorForm::updateTreeList(QString path, QStringList newDirs, QStringList newElements)
{
QStringList dirs = path.split("/");
dirs.removeFirst();
QTreeWidgetItem* iter = ui->treeWidget->topLevelItem(0);
for(QString dir : dirs)
{
for(int i=0; i<iter->childCount(); i++)
{
if(iter->child(i)->type() == TWT_DIR
&& iter->child(i)->text(0) == dir)
{
iter = iter->child(i);
}
}
}
for(QString dir : newDirs)
{
QTreeWidgetItem * newItem = new QTreeWidgetItem(TWT_DIR);
newItem->setText(0, dir);
iter->addChild( newItem );
}
for(QString element : newElements)
{
QTreeWidgetItem * newItem = new QTreeWidgetItem(TWT_RES);
newItem->setText(0, element);
iter->addChild( newItem );
}
ui->treeWidget->expandAll();
}
void CirclesDialog::reloadAll()
{
requestGroupMeta();
/* grab all ids */
std::list<std::string> friend_pgpIds;
std::list<std::string> all_pgpIds;
std::list<std::string>::iterator it;
std::set<std::string> friend_set;
rsPeers->getGPGAcceptedList(friend_pgpIds);
rsPeers->getGPGAllList(all_pgpIds);
/* clear tree */
ui.treeWidget_friends->clear();
/* add the top level item */
QTreeWidgetItem *friendsItem = new QTreeWidgetItem();
friendsItem->setText(0, tr("Friends"));
ui.treeWidget_friends->addTopLevelItem(friendsItem);
QTreeWidgetItem *fofItem = new QTreeWidgetItem();
fofItem->setText(0, tr("Friends Of Friends"));
ui.treeWidget_friends->addTopLevelItem(fofItem);
for(it = friend_pgpIds.begin(); it != friend_pgpIds.end(); it++)
{
RsPeerDetails details;
if (rsPeers->getGPGDetails(*it, details))
{
friend_set.insert(*it);
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setText(CIRCLEGROUP_FRIEND_COL_NAME, QString::fromUtf8(details.name.c_str()));
item->setText(CIRCLEGROUP_FRIEND_COL_ID, QString::fromStdString(*it));
friendsItem->addChild(item);
}
}
for(it = all_pgpIds.begin(); it != all_pgpIds.end(); it++)
{
if (friend_set.end() != friend_set.find(*it))
{
// already added as a friend.
continue;
}
RsPeerDetails details;
if (rsPeers->getGPGDetails(*it, details))
{
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setText(CIRCLEGROUP_FRIEND_COL_NAME, QString::fromUtf8(details.name.c_str()));
item->setText(CIRCLEGROUP_FRIEND_COL_ID, QString::fromStdString(*it));
fofItem->addChild(item);
}
}
}
void MainWindow::makeEmptyTree(){
ui->treeWidget->clear();
//Set tree widget table headers
ui->treeWidget->setColumnCount(4);
ui->treeWidget->headerItem()->setText(0,"");
ui->treeWidget->headerItem()->setText(1,"Academic Year");
ui->treeWidget->headerItem()->setText(2,"Hours");
ui->treeWidget->headerItem()->setText(3,"Students");
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setText(1,"0");
item->setText(2,"0");
item->setText(3,"0");
//build headers
QTreeWidgetItem *pme = root2("PME", "0", "0");
pme->addChild(item);
QTreeWidgetItem *ume = root2("UME", "0","0");
QTreeWidgetItem *item2 = new QTreeWidgetItem();
item->setText(1,"0");
item->setText(2,"0");
item->setText(3,"0");
ume->addChild(item2);
QTreeWidgetItem *cme = root2("CME", "0", "0");
QTreeWidgetItem *item3 = new QTreeWidgetItem();
item->setText(1,"0");
item->setText(2,"0");
item->setText(3,"0");
cme->addChild(item3);
QTreeWidgetItem *other = root2("Other", "0", "0");
QTreeWidgetItem *item4 = new QTreeWidgetItem();
item->setText(1,"0");
item->setText(2,"0");
item->setText(3,"0");
other->addChild(item4);
//hide tree
pme->setHidden(true);
cme->setHidden(true);
ume->setHidden(true);
other->setHidden(true);
//generate date ranges
for (int x = 1975; x <= 2015; x ++)
{
ui->comboBox_start->addItem(QString::number(x));
ui->comboBox_end->addItem(QString::number(x));
}
// set default date range
ui->comboBox_start->setCurrentIndex(0);
ui->comboBox_end->setCurrentIndex(ui->comboBox_end->count()-1);
}
QTreeWidgetItem * Widget::scanDirectory(QString path)
{
QTreeWidgetItem * root;
QDir myDir(path);
QTreeWidgetItem * tmp;
root = new QTreeWidgetItem(0);
root->setText(0, myDir.dirName());
QString dir = qApp->applicationDirPath();
QDirIterator * scanDir= new QDirIterator(path, QDir::AllEntries|QDir::NoDotAndDotDot);
QString nxt;
while(scanDir->hasNext())
{
nxt = scanDir->next();
qDebug(scanDir->filePath().toAscii());
if(scanDir->fileInfo().isDir())
{
root->addChild(scanDirectory(scanDir->filePath()));
totalDownloads++;
}
else
{
tmp = new QTreeWidgetItem(0);
tmp->setText(0, scanDir->fileName());
root->addChild(tmp);
totalDownloads++;
}
}
/*if(!nxt.isNull())
{
qDebug(scanDir->filePath().toAscii());
if(scanDir->fileInfo().isDir())
{
root->addChild(scanDirectory(scanDir->filePath()));
}
else
{
tmp = new QTreeWidgetItem(0);
tmp->setText(0, scanDir->fileName());
root->addChild(tmp);
}
}*/
return root;
}
void mtsQtCommandSelector::BuildTree(mtsManagerGlobal* globalComponentManager) {
clear();
QTreeWidgetItem* processItem;
QTreeWidgetItem* componentItem;
QTreeWidgetItem* interfaceItem;
QTreeWidgetItem* commandItem;
QStringList strings;
std::vector<std::string> processNames;
std::vector<std::string> componentNames;
std::vector<std::string> interfaceNames;
std::vector<std::string> commandNames;
globalComponentManager->GetNamesOfProcesses(processNames);
// Processes
for(std::vector<std::string>::const_iterator processName = processNames.begin(); processName < processNames.end(); ++processName) {
strings << processName->c_str() << "Process";
processItem = new QTreeWidgetItem(strings);
addTopLevelItem(processItem);
strings.clear();
// Components
componentNames.clear();
globalComponentManager->GetNamesOfComponents(*processName, componentNames);
for(std::vector<std::string>::const_iterator componentName = componentNames.begin(); componentName < componentNames.end(); ++componentName) {
strings << componentName->c_str() << "Component";
componentItem = new QTreeWidgetItem(strings);
processItem->addChild(componentItem);
strings.clear();
// Interfaces
interfaceNames.clear();
globalComponentManager->GetNamesOfInterfacesProvidedOrOutput(*processName, *componentName, interfaceNames);
for(std::vector<std::string>::const_iterator interfaceName = interfaceNames.begin(); interfaceName < interfaceNames.end(); ++interfaceName) {
strings << interfaceName->c_str() << "Interface";
interfaceItem = new QTreeWidgetItem(strings);
componentItem->addChild(interfaceItem);
strings.clear();
// Commands
commandNames.clear();
globalComponentManager->GetNamesOfCommands(*processName, *componentName, *interfaceName, commandNames);
for(std::vector<std::string>::const_iterator commandName = commandNames.begin(); commandName < commandNames.end(); ++commandName) {
strings << commandName->c_str() << "Command";
commandItem = new QTreeWidgetItem(strings);
interfaceItem->addChild(commandItem);
strings.clear();
}
}
}
}
}
void QJDMainWindow::setAreaWidget(QString areaString, QString areaPath, QStringList lineStringList,
QStringList linePathList, QVector<QStringList> flowStringList,
QVector<QStringList> flowPathList,QVector<QVector<QStringList> > dataStringList,
QVector<QVector<QStringList> > dataPathList)
{
// qDebug()<<"setAreaWidget::"<<flowStringList<<flowPathList;
QTreeWidgetItem *areaItem = new QTreeWidgetItem;
areaItem->setText(0,areaString);
areaItem->setToolTip(0,areaPath);
areaItem->setIcon(0,QIcon(":/src/images/area.png"));
for(int j=0; j<lineStringList.count(); j++)
{
QTreeWidgetItem *lineItem = new QTreeWidgetItem;
lineItem->setText(0,lineStringList.at(j));
lineItem->setToolTip(0,linePathList.at(j));
lineItem->setIcon(0,QIcon(":/src/images/line.png"));
for(int k=0; k<flowStringList[j].size(); k++)
{
QTreeWidgetItem *flowItem = new QTreeWidgetItem;
flowItem->setText(0,flowStringList[j].at(k));
flowItem->setToolTip(0,flowPathList[j].at(k));
if(flowStringList[j].at(k)=="Data")
{
flowItem->setIcon(0,QIcon(":/src/images/data.png"));
}
else
{
flowItem->setIcon(0,QIcon(":/src/images/flow.png"));
}
lineItem->addChild(flowItem);
// Scan/Pick
for(int l=0; l<dataStringList[j][k].size(); l++)
{
QTreeWidgetItem *dataItem = new QTreeWidgetItem;
dataItem->setText(0,dataStringList[j][k].at(l));
dataItem->setToolTip(0,dataPathList[j][k].at(l));
// dataItem->setIcon(0,QIcon(":/src/images/flow.png"));
flowItem->addChild(dataItem);
// qDebug()<<lineStringList.count()<<j<<flowStringList[j].size()<<k<<dataStringList[k].size()<<l;
}
}
areaItem->addChild(lineItem);
}
areaWidget->addTopLevelItem(areaItem);
}
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 EditTache::loadProjects()
{
ProjetManager& manager = ProjetManager::Instance();
unsigned int nbProj = manager.getNb();
QTreeWidget * tree = ui->treeWidget;
for(int i = 0; i < nbProj; i++)
{
QTreeWidgetItem * projet = new QTreeWidgetItem();
Projet& proj = manager.getProjet(i);
unsigned int nbTaches = proj.getNb();
projet->setText(0, QString::fromStdString(proj.getTitre()));
for(int i=0; i < nbTaches; i++)
{
QTreeWidgetItem * tache = new QTreeWidgetItem();
Tache& t = proj.getTache(i);
tache->setText(0, QString::fromStdString(t.getTitre()));
projet->addChild(tache);
}
tree->addTopLevelItem(projet);
}
}
void MainWindow::ChunksToDisplay(CIffHeader *pHead, QTreeWidgetItem *pTopItem)
{
// root-level chunk-nodes
CIffChunk *pChunk = pHead->m_pFirst;
while (pChunk != nullptr)
{
QTreeWidgetItem *pChunkItem = new QTreeWidgetItem(pTopItem);
pChunkItem->setText(0, IdToString(pChunk->m_iChunkID));
pChunkItem->setText(1, QString::number(pChunk->m_iOffset));
pChunkItem->setText(2, QString::number(pChunk->m_iChunkSize));
pTopItem->addChild(pChunkItem);
CIffSubChunk *pSubChunk = pChunk->m_pSubChunk;
while (pSubChunk != nullptr)
{
QTreeWidgetItem *pSubItem = new QTreeWidgetItem(pChunkItem);
pSubItem->setText(0, IdToString(pSubChunk->m_iChunkID));
pSubItem->setText(1, QString::number(pSubChunk->m_iOffset));
pSubItem->setText(2, QString::number(pSubChunk->m_iSize));
pChunkItem->addChild(pSubItem);
pSubChunk = pSubChunk->m_pNextSub;
}
pChunk = pChunk->m_pNext;
}
}
/*
Update the file browser to show files in the project.
Read these from the project's project file.
*/
void ProjectInfo::loadFileBrowser(QDir *projectDir, QDomDocument *projectFile)
{
// setup the file browser
fileBrowser->clear(); // get rid of anything previously in there
QDomNodeList allFiles = projectFile->elementsByTagName("files").at(0).childNodes();
QTreeWidgetItem *top = new QTreeWidgetItem(QStringList() << projectDir->dirName());
top->setIcon(0, QApplication::style()->standardIcon(QStyle::SP_DirIcon));
fileBrowser->addTopLevelItem(top);
// only deals with files in the top level directory at the moment
QFileIconProvider ip;
for(int i = 0; i < allFiles.count(); i++)
{
QFileInfo fi(projectDir->filePath(allFiles.at(i).toElement().text()));
if(!fi.fileName().isEmpty())
{
if(projectDir->exists(fi.fileName()))
{
QString buildtype = allFiles.at(i).toElement().attribute("type");
QTreeWidgetItem *child = new QTreeWidgetItem(QStringList() << fi.fileName() << buildtype);
child->setData(FILENAME_COLUMN, FULLPATH_ROLE, fi.filePath());
child->setToolTip(FILENAME_COLUMN, fi.filePath());
child->setIcon(FILENAME_COLUMN, ip.icon(fi));
top->addChild(child);
}
}
}
top->setExpanded(true);
}
KMibwalker::KMibwalker ( QWidget* parent ) : KXmlGuiWindow ( parent ), Ui_KMibwalker() {
setupUi(this);
setupActions();
mibTree->setHeaderLabel(i18n("MIB Viewer"));
QString top = QString("iso.org.dod.internet.mgmt.mib-2");
QTreeWidgetItem* root = new QTreeWidgetItem(mibTree, QStringList(top));
root->addChild(new QTreeWidgetItem(root, QStringList("system")));
root->addChild(new QTreeWidgetItem(root, QStringList("interfaces")));
root->addChild(new QTreeWidgetItem(root, QStringList("at")));
root->addChild(new QTreeWidgetItem(root, QStringList("ip")));
root->addChild(new QTreeWidgetItem(root, QStringList("icmp")));
root->addChild(new QTreeWidgetItem(root, QStringList("tcp")));
root->addChild(new QTreeWidgetItem(root, QStringList("udp")));
mibTree->addTopLevelItem(root);
}
void InsertFxPopup::loadMacro()
{
TFilePath fp = m_presetFolder + TFilePath("macroFx");
try {
if (TFileStatus(fp).isDirectory()) {
TFilePathSet macros = TSystem::readDirectory(fp);
if (macros.empty())
return;
QTreeWidgetItem *macroFolder = new QTreeWidgetItem((QTreeWidget *)0, QStringList(tr("Macro")));
macroFolder->setData(0, Qt::UserRole, QVariant(toQString(fp)));
macroFolder->setIcon(0, m_folderIcon);
m_fxTree->addTopLevelItem(macroFolder);
for (TFilePathSet::iterator it = macros.begin(); it != macros.end(); ++it) {
TFilePath macroPath = *it;
QString name(macroPath.getName().c_str());
QTreeWidgetItem *macroItem = new QTreeWidgetItem((QTreeWidget *)0, QStringList(name));
macroItem->setData(0, Qt::UserRole, QVariant(toQString(macroPath)));
macroItem->setIcon(0, m_fxIcon);
macroFolder->addChild(macroItem);
}
}
} catch (...) {
}
}
bool BookmarkGui::addEvaluation( QString stars )
{
Bookmark bk ;
QueryResult favorite ;
bk.getFavoriteFullData( favorite , this->current_favorite );
QList<QTreeWidgetItem *> list_evaluations =
ui->treeEvaluations->findItems ( stars , Qt::MatchExactly , 1 ) ;
qDebug() << list_evaluations.isEmpty() << list_evaluations.size() << stars ;
if ( list_evaluations.isEmpty() || list_evaluations.size() > 1 ) return false ;
QTreeWidgetItem *evaluation = list_evaluations.first() ;
if ( evaluation->type() != BookmarkGui::item_evaluation ) return false ;
QTreeWidgetItem* item = new QTreeWidgetItem( (QTreeWidgetItem*)0 , BookmarkGui::item_article ) ;
this->setArticleItemDecorations( item , this->current_favorite , this->current_favorite_id ) ;
evaluation->addChild( item ) ;
evaluation->setExpanded( true ) ;
ui->treeEvaluations->setCurrentItem( item );
return true ;
}
void LibraryTreeWidget::importToLibrary()
{
QTreeWidgetItem* root = invisibleRootItem();
if (selectedItems().empty() == false)
root = selectedItems().front();
QString path = QFileInfo(projectFileName_).path();
QDir dir(path);
QStringList fileNames = QFileDialog::getOpenFileNames(this, tr("Import to Library"), path, tr("All Files (*.*)"));
QStringList::Iterator it = fileNames.begin();
while(it != fileNames.end())
{
QString fileName = dir.relativeFilePath(*it);
if (isFileAlreadyImported(fileName))
{
QMessageBox::information(this, tr("Gideros"), tr("The file '%1' cannot be added to the library because it is already a member of the library.").arg(fileName));
}
else
{
QTreeWidgetItem *item = createFileItem(fileName);
if (root == invisibleRootItem())
root->addChild(item);
else
root->insertChild(0, item);
root->setExpanded(true);
}
++it;
}
checkModification();
}
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 Settings::FaceManagementPage::loadDatabase()
{
m_databaseEntries->clear();
m_databaseEntries->setSortingEnabled(false);
m_recognizer = FaceManagement::Recognizer::instance();
QMap<QString, QStringList> parsedIdentities = m_recognizer->allParsedIdentities();
QMapIterator<QString, QStringList> tagList(parsedIdentities);
while (tagList.hasNext()) {
tagList.next();
QTreeWidgetItem* category = new QTreeWidgetItem;
category->setText(0, tagList.key());
category->setFlags(Qt::ItemIsEnabled);
for (int i = 0; i < tagList.value().size(); ++i) {
QTreeWidgetItem* tag = new QTreeWidgetItem;
tag->setText(0, tagList.value().at(i));
tag->setText(1, QString::number(m_recognizer->getHistogramCount(tagList.key(),
tagList.value().at(i))));
tag->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
category->addChild(tag);
}
m_databaseEntries->addTopLevelItem(category);
category->setExpanded(true);
}
m_databaseEntries->setEnabled(true);
m_databaseEntries->setSortingEnabled(true);
m_databaseEntries->sortItems(0, Qt::AscendingOrder);
}
void AssetsWindow::AddAsset(AssetPtr asset)
{
///\todo Check that the asset doesn't already exists
AssetItem *item = new AssetItem(asset);
AddChildren(asset, item);
connect(asset.get(), SIGNAL(Loaded(AssetPtr)), SLOT(HandleAssetLoaded(AssetPtr)));
connect(asset.get(), SIGNAL(Unloaded(IAsset *)), SLOT(HandleAssetUnloaded(IAsset *)));
bool storageFound = false;
AssetStoragePtr storage = asset->GetAssetStorage();
if (storage)
for(int i = 0; i < treeWidget->topLevelItemCount(); ++i)
{
QTreeWidgetItem *storageItem = treeWidget->topLevelItem(i);
if (storageItem->text(0) == storage->ToString())
{
storageItem->addChild(item);
storageFound = true;
break;
}
}
if (!storageFound)
noProviderItem->addChild(item);
noProviderItem->setHidden(noProviderItem->childCount() == 0);
}
void PackageProperties::populateFileWidget()
{
treeWidget->clear();
treeWidget->header()->hide();
QStringList files = curPkg.files();
foreach(const QString &file, files) {
QStringList splitted = file.split(QChar('/'));
QTreeWidgetItem *parentItem = 0;
foreach(const QString &spl, splitted) {
if (spl.isEmpty())
continue;
if (parentItem) {
bool there = false;
int j = parentItem->childCount();
for (int i = 0; i != j; i++) {
if (parentItem->child(i)->text(0) == spl) {
there = true;
parentItem = parentItem->child(i);
continue;
}
}
if (!there)
parentItem->addChild(new QTreeWidgetItem(parentItem, (QStringList) spl));
} else {
QList<QTreeWidgetItem*> list = treeWidget->findItems(spl, Qt::MatchExactly);
if (!list.isEmpty()) {
parentItem = list.first();
} else {
treeWidget->insertTopLevelItem(0, new QTreeWidgetItem(treeWidget, (QStringList) spl));
}
}
}
}
CategoryWidget::CategoryWidget(QWidget *parent) : QTreeWidget(parent), d(new CategoryWidgetPrivate()) {
connect(this, SIGNAL(clicked(QModelIndex)), this, SLOT(toggleItemState(QModelIndex)));
connect(this, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)), this, SLOT(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)));
// get elements from the element manager
QStringList categories = ElementManager::instance()->categories();
// create the category nodes
QHash<QString, QTreeWidgetItem *> categoryNodes;
foreach(QString category, categories) {
QTreeWidgetItem *parent = 0;
int numSections = category.count("/") + 1;
for (int i = 0; i < numSections; ++i) {
QString path = category.section("/", 0, i, QString::SectionSkipEmpty);
if (!categoryNodes.contains(path)) {
QTreeWidgetItem *node = new QTreeWidgetItem();
if (parent == 0)
this->addTopLevelItem(node);
else
parent->addChild(node);
QString name = category.section("/", i, i, QString::SectionSkipEmpty);
node->setText(0, qApp->translate("Categories", name.toUtf8()));
node->setData(0, Qt::UserRole, name);
node->setData(1, Qt::UserRole, path);
// use bigger fonts for items at higher levels
QFont font = node->font(0);
font.setPointSize(font.pointSize() + 2 - qMin(i, 3));
node->setFont(0, font);
if (i >= 3)
node->setTextColor(0, QColor(96, 96, 96));
categoryNodes[path] = node;
}
parent = categoryNodes[path];
}
}
QTreeWidgetItem* LXQtWorldClockConfigurationTimeZones::makeSureParentsExist(const QStringList &parts, QMap<QString, QTreeWidgetItem*> &parentItems)
{
if (parts.length() == 1)
return 0;
QStringList parentParts = parts.mid(0, parts.length() - 1);
QString parentPath = parentParts.join(QLatin1String("/"));
QMap<QString, QTreeWidgetItem*>::Iterator I = parentItems.find(parentPath);
if (I != parentItems.end())
return I.value();
QTreeWidgetItem* newItem = new QTreeWidgetItem(QStringList() << parts[parts.length() - 2]);
QTreeWidgetItem* parentItem = makeSureParentsExist(parentParts, parentItems);
if (!parentItem)
ui->timeZonesTW->addTopLevelItem(newItem);
else
parentItem->addChild(newItem);
parentItems[parentPath] = newItem;
return newItem;
}
void LBMStreamEntry::processPacket(const packet_info * pinfo, const lbm_uim_stream_tap_info_t * stream_info)
{
LBMSubstreamEntry * substream = NULL;
LBMSubstreamMapIterator it;
if (m_first_frame > pinfo->num)
{
m_first_frame = pinfo->num;
}
if (m_flast_frame < pinfo->num)
{
m_flast_frame = pinfo->num;
}
m_bytes += stream_info->bytes;
m_messages++;
it = m_substreams.find(stream_info->substream_id);
if (m_substreams.end() == it)
{
QTreeWidgetItem * item = NULL;
substream = new LBMSubstreamEntry(m_channel, stream_info->substream_id, &(pinfo->src), pinfo->srcport, &(pinfo->dst), pinfo->destport);
m_substreams.insert(stream_info->substream_id, substream);
item = new QTreeWidgetItem();
substream->setItem(item);
m_item->addChild(item);
m_item->sortChildren(Stream_Column, Qt::AscendingOrder);
}
else
{
substream = it.value();
}
fillItem();
substream->processPacket(pinfo->num, stream_info->bytes);
}
bool BookmarkGui::addState( QString new_state )
{
Bookmark bk ;
QueryResult favorite ;
bk.getFavoriteFullData( favorite , this->current_favorite );
QList<QTreeWidgetItem *> list_state =
ui->treeStates->findItems ( new_state , Qt::MatchExactly ) ;
if ( list_state.isEmpty() || list_state.size() > 1 ) return false ;
QTreeWidgetItem *state = list_state.first() ;
if ( state->type() != BookmarkGui::item_state ) return false ;
QTreeWidgetItem* item = new QTreeWidgetItem( (QTreeWidgetItem*)0 , BookmarkGui::item_article ) ;
this->setArticleItemDecorations( item , this->current_favorite , this->current_favorite_id ) ;
state->addChild( item ) ;
state->setExpanded( true ) ;
ui->treeStates->setCurrentItem( item );
return true ;
}
// Add changed/added items:
foreach (int a, toAdd) {
BaseQtVersion *version = QtVersionManager::version(a)->clone();
m_versions.append(version);
QTreeWidgetItem *item = new QTreeWidgetItem;
item->setText(0, version->displayName());
item->setText(1, version->qmakeCommand().toUserOutput());
item->setData(0, VersionIdRole, version->uniqueId());
item->setData(0, ToolChainIdRole, defaultToolChainId(version));
const ValidityInfo info = validInformation(version);
item->setIcon(0, info.icon);
// Insert in the right place:
QTreeWidgetItem *parent = version->isAutodetected()? m_autoItem : m_manualItem;
for (int i = 0; i < parent->childCount(); ++i) {
BaseQtVersion *currentVersion = m_versions.at(indexForTreeItem(parent->child(i)));
if (currentVersion->qtVersion() > version->qtVersion())
continue;
parent->insertChild(i, item);
parent = 0;
break;
}
if (parent)
parent->addChild(item);
}
MobileNotificationSettings::MobileNotificationSettings(QWidget *parent) :
qutim_sdk_0_3::SettingsWidget(parent)
{
QVBoxLayout *layout = new QVBoxLayout(this);
layout->setContentsMargins(0, 6, 6, 6);
m_typesWidget = new QTreeWidget(this);
m_typesWidget->setAlternatingRowColors(true);
m_typesWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
m_typesWidget->header()->hide();
foreach (NotificationBackend *backend, NotificationBackend::all()) {
QString backendDesc = backend->description();
if (backendDesc.isEmpty())
backendDesc = LocalizedString(backend->backendType());
QTreeWidgetItem *backendItem = new NotificationTreeItem(m_typesWidget, QIcon(), backendDesc);
backendItem->setData(0, BackendTypeRole, backend->backendType());
backendItem->setCheckState(0, Qt::PartiallyChecked);
Backend tmp = { backend, backendItem };
m_backends.push_back(tmp);
for (int i = 0; i <= Notification::LastType; ++i) {
Notification::Type type = static_cast<Notification::Type>(i);
QString typeDesc = Notification::typeString(type);
QTreeWidgetItem *item = new NotificationTreeItem(typeDesc);
item->setData(0, NotificationTypeRole, i);
backendItem->addChild(item);
}
}
void HelpTreeWidget::openJsonDocument(const QString &filepath)
{
QJsonDocument doc;
QFile helpFile(filepath);
if (!helpFile.open(QIODevice::ReadOnly)) {
qWarning("Could not open pro file");
return;
}
QByteArray jData = helpFile.readAll();
helpFile.close();
doc = QJsonDocument::fromJson(jData);
QJsonObject obj = doc.object();
QJsonArray jarray = obj["help"].toArray();
for (int i = 0; i < jarray.size(); i++)
{
QString itemName = jarray.at(i).toObject()["name"].toString();
QString itemDdsc = jarray.at(i).toObject()["dsc"].toString();
QTreeWidgetItem *name = new QTreeWidgetItem();
QTreeWidgetItem *dsc = new QTreeWidgetItem();
name->setData(0, Qt::DisplayRole, itemName);
dsc->setData(0, Qt::DisplayRole, itemDdsc);
name->addChild(dsc);
m_tree->addTopLevelItem(name);
}
}
void OutlineWidget::Update()
{
for (list<Block>::const_iterator bi = blocks->begin(); bi != blocks->end(); bi++)
{
QString blockTexturePath = QString::fromStdString(Asset::GetInstance()->GetTexturePath(bi->GetTexture()));
QString blockTextureName = Asset::GetInstance()->GetTextureName(bi->GetTexture());
QTreeWidgetItem *blockItem = FindBlockItem(blockTextureName);
if(blockItem != NULL)
{
blockItem->child(0)->setText(0, QString("%1").arg(bi->cells.size()));
}
else
{
QTreeWidgetItem *item = new QTreeWidgetItem;
item->setText(0, blockTextureName);
item->setIcon(0, QIcon(QPixmap(blockTexturePath).scaled(ITEM_ICON_SIZE, ITEM_ICON_SIZE)));
QTreeWidgetItem *childItem = new QTreeWidgetItem;
childItem->setText(0, QString("%1").arg(bi->cells.size()));
item->addChild(childItem);
treeWidget->topLevelItem(0)->addChild(item);
}
}
}
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);
}
/* Méthode qui charge les modèles OBJ */
void HomeCreator3D::loadModels()
{
models.insert("Chair", new Model("models/chair.obj", 0.0005,0.0));
models.insert("Chair2", new Model("models/chair2.obj", 0.0013,0.0));
models.insert("Table", new Model("models/table.obj", 1.6,0.0));
models.insert("Bookcase", new Model("models/bookcase.obj", 0.001,0.0));
models.insert("Piano", new Model("models/piano.obj", 1.0,0.0));
models.insert("Soccerball", new Model("models/soccerball.obj", 0.03,4.5));
models.insert("Flowers", new Model("models/flowers.obj", 0.06,12.0));
QTreeWidgetItem* objects = new QTreeWidgetItem();
objects->setText(0, "Objets");
QList<QString> keys(models.keys());
for (int i = 0; i < keys.size(); ++i)
{
QTreeWidgetItem* item = new QTreeWidgetItem();
item->setText(0, keys[i]);
objects->addChild(item);
}
window.getUi()->treeWidget->insertTopLevelItem(1, objects);
}
