void AddFixture::fillTree(const QString& selectManufacturer,
const QString& selectModel)
{
QTreeWidgetItem* parent;
QTreeWidgetItem* child;
QString manuf;
QString model;
/* Clear the tree of any previous data */
m_tree->clear();
/* Add all known fixture definitions to the tree */
QStringListIterator it(m_fixtureDefCache.manufacturers());
while (it.hasNext() == true)
{
manuf = it.next();
parent = new QTreeWidgetItem(m_tree);
parent->setText(KColumnName, manuf);
QStringListIterator modit(m_fixtureDefCache.models(manuf));
while (modit.hasNext() == true)
{
model = modit.next();
child = new QTreeWidgetItem(parent);
child->setText(KColumnName, model);
if (manuf == selectManufacturer &&
model == selectModel)
{
parent->setExpanded(true);
m_tree->setCurrentItem(child);
}
}
}
/* Create a parent and a child for generic dimmer device */
parent = new QTreeWidgetItem(m_tree);
parent->setText(KColumnName, KXMLFixtureGeneric);
child = new QTreeWidgetItem(parent);
child->setText(KColumnName, KXMLFixtureGeneric);
/* Select generic dimmer by default */
if (selectManufacturer == KXMLFixtureGeneric &&
selectModel == KXMLFixtureGeneric)
{
parent->setExpanded(true);
m_tree->setCurrentItem(child);
}
}
void AddComponentDialog::searchComponents(const QString& input) {
setSelectedComponent(nullptr);
mUi->treeComponents->clear();
// min. 2 chars to avoid freeze on entering first character due to huge result
if (input.length() > 1) {
SearchResult result = searchComponentsAndDevices(input);
QHashIterator<FilePath, SearchResultComponent> cmpIt(result);
while (cmpIt.hasNext()) {
cmpIt.next();
QTreeWidgetItem* cmpItem = new QTreeWidgetItem(mUi->treeComponents);
cmpItem->setText(0, cmpIt.value().name);
cmpItem->setData(0, Qt::UserRole, cmpIt.key().toStr());
QHashIterator<FilePath, SearchResultDevice> devIt(cmpIt.value().devices);
while (devIt.hasNext()) {
devIt.next();
QTreeWidgetItem* devItem = new QTreeWidgetItem(cmpItem);
devItem->setText(0, devIt.value().name);
devItem->setData(0, Qt::UserRole, devIt.key().toStr());
devItem->setText(1, devIt.value().pkgName);
devItem->setTextAlignment(1, Qt::AlignRight);
}
cmpItem->setText(1, QString("[%1]").arg(cmpIt.value().devices.count()));
cmpItem->setTextAlignment(1, Qt::AlignRight);
cmpItem->setExpanded(!cmpIt.value().match);
}
}
mUi->treeComponents->sortByColumn(0, Qt::AscendingOrder);
}
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 HierarchyTreeWidget::AddControlItem(QTreeWidgetItem* parent, const EXPANDEDITEMS& selectedItems, const EXPANDEDITEMS& expandedItems, const HierarchyTreeNode::HIERARCHYTREENODESLIST& items)
{
for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = items.begin();
iter != items.end();
++iter)
{
const HierarchyTreeControlNode* controlNode = (const HierarchyTreeControlNode*)(*iter);
QTreeWidgetItem* controlItem = new QTreeWidgetItem();
controlItem->setData(ITEM_ID, controlNode->GetId());
controlItem->setText(0, controlNode->GetName());
Decorate(controlItem, controlNode->GetUIObject());
parent->insertChild(parent->childCount(), controlItem);
AddControlItem(controlItem, selectedItems, expandedItems, controlNode->GetChildNodes());
if (expandedItems.find(controlNode->GetId()) != expandedItems.end())
controlItem->setExpanded(true);
if (selectedItems.find(controlNode->GetId()) != selectedItems.end())
{
controlItem->setSelected(true);
}
}
}
QTreeWidgetItem *FixtureRemap::getUniverseItem(quint32 universe, QTreeWidget *tree)
{
QTreeWidgetItem *topItem = NULL;
for (int i = 0; i < tree->topLevelItemCount(); i++)
{
QTreeWidgetItem* tItem = tree->topLevelItem(i);
quint32 tUni = tItem->text(KColumnUniverse).toUInt();
if (tUni == universe)
{
topItem = tItem;
break;
}
}
// Haven't found this universe node ? Create it.
if (topItem == NULL)
{
topItem = new QTreeWidgetItem(tree);
topItem->setText(KColumnName, tr("Universe %1").arg(universe + 1));
topItem->setText(KColumnUniverse, QString::number(universe));
topItem->setText(KColumnID, QString::number(Function::invalidId()));
topItem->setExpanded(true);
}
return topItem;
}
void RSSWidget::askNewFolder()
{
bool ok;
QString newName = AutoExpandableDialog::getText(
this, tr("Please choose a folder name"), tr("Folder name:"), QLineEdit::Normal
, tr("New folder"), &ok);
if (!ok) return;
newName = newName.trimmed();
if (newName.isEmpty()) return;
// Determine destination folder for new item
QTreeWidgetItem *destItem = nullptr;
QList<QTreeWidgetItem *> selectedItems = m_feedListWidget->selectedItems();
if (!selectedItems.empty()) {
destItem = selectedItems.first();
if (!m_feedListWidget->isFolder(destItem))
destItem = destItem->parent();
}
// Consider the case where the user clicked on Unread item
RSS::Folder *rssDestFolder = ((!destItem || (destItem == m_feedListWidget->stickyUnreadItem()))
? RSS::Session::instance()->rootFolder()
: qobject_cast<RSS::Folder *>(m_feedListWidget->getRSSItem(destItem)));
QString error;
const QString newFolderPath = RSS::Item::joinPath(rssDestFolder->path(), newName);
if (!RSS::Session::instance()->addFolder(newFolderPath, &error))
QMessageBox::warning(this, "qBittorrent", error, QMessageBox::Ok);
// Expand destination folder to display new feed
if (destItem && (destItem != m_feedListWidget->stickyUnreadItem()))
destItem->setExpanded(true);
// As new RSS items are added synchronously, we can do the following here.
m_feedListWidget->setCurrentItem(m_feedListWidget->mapRSSItem(RSS::Session::instance()->itemByPath(newFolderPath)));
}
/**
* @brief MainWindow::on_pushButtonRefresh_clicked
*/
void MainWindow::on_pushButtonRefresh_clicked()
{
qDebug() debugprefix << "on_pushButtonRefresh_clicked() scanning channels" ;
int c,i;
treeWidgetItems.clear();
ui->treeWidgetInterfaces->clear();
canStatus stat = canGetNumberOfChannels(&c);
if( canOK == stat ){
for (i=0; i < c; i++) {
char tmp[255];
stat = canGetChannelData(i, canCHANNELDATA_DEVDESCR_ASCII, &tmp, sizeof(tmp));
if (stat < 0){
char buf[128];
canGetErrorText(stat,buf,128);
qDebug() debugprefix << "canGetChannelData() " << buf ;
}else{
QTreeWidgetItem *port = new QTreeWidgetItem(ui->treeWidgetInterfaces);
QTreeWidgetItem *name = new QTreeWidgetItem(port);
port->setText(0, QString().setNum(i,10));
name->setText(0, QString(tmp));
qDebug() debugprefix << "canGetChannelData("<< i << ") " << tmp;
port->setExpanded(true);
}
}
}else{
char buf[128];
canGetErrorText(stat,buf,128);
qDebug() debugprefix << "canGetNumberOfChannels() " << buf ;
}
}
/**
* Add a classifier to the data structure.
* @param classifier the classifier to add
* @param parent the tree item under which the classifier is placed
* @param addSuper add it to the base classifier folder
* @param addSub add it to the derived classifier folder
* @param recurse ...
*/
void RefactoringAssistant::addClassifier(UMLClassifier *classifier, QTreeWidgetItem *parent, bool addSuper, bool addSub, bool recurse)
{
if (!classifier) {
uWarning() << "No classifier given - do nothing!";
return;
}
DEBUG(DBG_SRC) << classifier->name() << " added.";
QTreeWidgetItem *classifierItem, *item;
if (parent) {
classifierItem = parent;
}
else {
classifierItem = new QTreeWidgetItem(this, QStringList(classifier->name()));
m_umlObjectMap[classifierItem] = classifier;
}
m_alreadySeen << classifier;
connect(classifier, SIGNAL(modified()),
this, SLOT(objectModified()));
// add attributes
connect(classifier, SIGNAL(attributeAdded(UMLClassifierListItem*)),
this, SLOT(attributeAdded(UMLClassifierListItem*)));
connect(classifier, SIGNAL(attributeRemoved(UMLClassifierListItem*)),
this, SLOT(attributeRemoved(UMLClassifierListItem*)));
QStringList itemTextAt;
itemTextAt << i18n("Attributes") << QLatin1String("attributes");
QTreeWidgetItem *attsFolder = new QTreeWidgetItem(classifierItem, itemTextAt);
attsFolder->setIcon(0, Icon_Utils::SmallIcon(Icon_Utils::it_Folder_Orange));
attsFolder->setExpanded(true);
UMLAttributeList atts(classifier->getAttributeList());
foreach(UMLAttribute* att, atts) {
attributeAdded(att);
}
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 FMODSoundBrowser::SelectItemAndExpandTreeByEventName(const DAVA::String & eventName)
{
DAVA::Vector<DAVA::String> tokens;
DAVA::Split(eventName, "/", tokens);
DAVA::int32 tokensCount = tokens.size();
QTreeWidgetItem * currentItem = ui->treeWidget->invisibleRootItem();
for(DAVA::int32 i = 0; i < tokensCount; i++)
{
QString currentToken = QString(tokens[i].c_str());
DAVA::int32 childrenCount = currentItem->childCount();
QTreeWidgetItem * findedItem = 0;
for(DAVA::int32 k = 0; k < childrenCount; k++)
{
QTreeWidgetItem * currentChild = currentItem->child(k);
if(currentChild->text(0) == currentToken)
{
findedItem = currentChild;
findedItem->setExpanded(true);
break;
}
}
if(!findedItem)
return;
currentItem = findedItem;
}
currentItem->setSelected(true);
}
void QSofaListView::expandPath(const std::string& path)
{
if(path.empty())
return;
if(path.data()[0] != '/')
return;
Node* match = down_cast<Node>( graphListener_->findObject(this->topLevelItem(0))->toBaseNode() );
QStringList tokens = QString::fromStdString(path).split('/') ;
for(int i=1;i<tokens.size();i++)
{
match = match->getChild(tokens[i].toStdString());
if(match == nullptr)
return;
if(graphListener_->items.find(match) != graphListener_->items.end())
{
QTreeWidgetItem* item = graphListener_->items[match] ;
item->setExpanded ( true );
}
}
}
void MainWindow::addSubscriber()
{
QTreeWidgetItemIterator it(ui->treeWidget);
while (*it)
{
(*it)->setSelected(false);
(*it)->setExpanded(false);
++it;
}
QTreeWidgetItem *sub = new QTreeWidgetItem(ui->treeWidget);
sub->setText(0, QString("Brak identyfikatora #") + QString::number(ui->treeWidget->model()->rowCount()));
QTreeWidgetItem *id = new QTreeWidgetItem(sub);
id->setText(0, "#:");
id->setText(1, QString::number(ui->treeWidget->model()->rowCount()));
QTreeWidgetItem *mail = new QTreeWidgetItem(sub);
mail->setText(0, "E-mail:");
mail->setText(1, "brak");
QTreeWidgetItem *phone = new QTreeWidgetItem(sub);
phone->setText(0, "Telefon:");
phone->setText(1, "brak");
QTreeWidgetItem *notification = new QTreeWidgetItem(sub);
notification->setText(0, "Typ powiadomienia:");
notification->setText(1, "brak");
sub->setSelected(true);
sub->setExpanded(true);
ui->treeWidget->insertTopLevelItem(0, sub);
ui->treeWidget->scrollToBottom();
selectedSubscriber = NULL;
}
void Parametertuner::handleExpansion(int dir)
{
// Error checking
if(dir != COLLAPSE) return;
// Declare variables
QTreeWidgetItem* thisItem;
QTreeWidgetItem* parentItem;
// Get the currently selected item
thisItem = getSelectedItem(); // Careful: This may still be null!
// Handle case where collapse has been requested
if(dir == COLLAPSE)
{
// Can't collapse the whole root
if(!thisItem) return;
if(!itemHasParent(thisItem)) return;
// Collapse the parent item of the currently selected item
parentItem = itemGetParent(thisItem);
updateSelection(thisItem, parentItem);
parentItem->setExpanded(false);
// Done
return;
}
}
void RSSImp::loadFoldersOpenState()
{
QStringList open_folders = Preferences::instance()->getRssOpenFolders();
foreach (const QString& var_path, open_folders) {
QStringList path = var_path.split("\\");
QTreeWidgetItem* parent = 0;
foreach (const QString& name, path) {
int nbChildren = 0;
if (parent)
nbChildren = parent->childCount();
else
nbChildren = m_feedList->topLevelItemCount();
for (int i = 0; i < nbChildren; ++i) {
QTreeWidgetItem* child;
if (parent)
child = parent->child(i);
else
child = m_feedList->topLevelItem(i);
if (m_feedList->getRSSItem(child)->id() == name) {
parent = child;
parent->setExpanded(true);
qDebug("expanding folder %s", qPrintable(name));
break;
}
}
}
void HierarchyTreeWidget::OnSelectedControlNodesChanged(const HierarchyTreeController::SELECTEDCONTROLNODES &selectedControls)
{
if (internalSelectionChanged)
return;
internalSelectionChanged = true;
ResetSelection();
TREEITEMS items = GetAllItems();
for (HierarchyTreeController::SELECTEDCONTROLNODES::const_iterator iter = selectedControls.begin();
iter != selectedControls.end();
++iter)
{
const HierarchyTreeControlNode* node = (*iter);
TREEITEMS::iterator itemIter = items.find(node->GetId());
if (itemIter != items.end())
{
QTreeWidgetItem* item = itemIter->second;
item->setSelected(true);
// Force show selected item
QTreeWidgetItem* parentItem = item->parent();
while (parentItem)
{
parentItem->setExpanded(true);
parentItem = parentItem->parent();
}
}
}
internalSelectionChanged = false;
}
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);
}
QTreeWidgetItem *ChannelTreeWidget::addRootItem(const QString &text)
{
QTreeWidgetItem *item = new QTreeWidgetItem(this);
item->setText(0, text);
item->setExpanded(true);
return item;
}
void SettingsDlg::registerSettingsPage(SettingsPage *sp)
{
sp->setParent(ui.settingsStack);
ui.settingsStack->addWidget(sp);
connect(sp, SIGNAL(changed(bool)), this, SLOT(setButtonStates()));
QTreeWidgetItem *cat;
QList<QTreeWidgetItem *> cats = ui.settingsTree->findItems(sp->category(), Qt::MatchExactly);
if (!cats.count()) {
cat = new QTreeWidgetItem(ui.settingsTree, QStringList(sp->category()));
cat->setExpanded(true);
cat->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
}
else {
cat = cats[0];
}
QTreeWidgetItem *item;
if (sp->title().isEmpty())
item = cat;
else
item = new QTreeWidgetItem(cat, QStringList(sp->title()));
item->setData(0, SettingsPageRole, QVariant::fromValue<QObject *>(sp));
ui.settingsTree->setMinimumWidth(ui.settingsTree->header()->sectionSizeHint(0) + 5);
pageIsLoaded[sp] = false;
if (!ui.settingsTree->selectedItems().count())
ui.settingsTree->setCurrentItem(item);
setItemState(item);
}
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 ;
}
void LocalPointValueView::doShowPoint()
{
logMessage("LocalPointValueView::doShowPoint()");
trvWidget->clear();
// point
QTreeWidgetItem *pointNode = new QTreeWidgetItem(trvWidget);
pointNode->setText(0, tr("Point"));
pointNode->setExpanded(true);
addTreeWidgetItemValue(pointNode, Util::scene()->problemInfo()->labelX() + ":", QString("%1").arg(point.x, 0, 'f', 5), tr("m"));
addTreeWidgetItemValue(pointNode, Util::scene()->problemInfo()->labelY() + ":", QString("%1").arg(point.y, 0, 'f', 5), tr("m"));
trvWidget->insertTopLevelItem(0, pointNode);
if (Util::scene()->sceneSolution()->isSolved())
{
LocalPointValue *value = Util::scene()->problemInfo()->hermes()->localPointValue(point);
Util::scene()->problemInfo()->hermes()->showLocalValue(trvWidget, value);
delete value;
}
trvWidget->resizeColumnToContents(2);
}
void Tree::trier(int forme)
{
// fichiers SF2 par ordre alphabétique
int max = this->topLevelItemCount();
QTreeWidgetItem *child;
this->sortItems(0, Qt::AscendingOrder); // colonne 5 ne fonctionne pas ?!
for (int i = 0; i < max; i ++)
this->topLevelItem(i)->sortChildren(5, Qt::AscendingOrder);
if (forme)
{
// Mise en forme (expanded / collapsed)
for (int i = 0; i < max; i++)
{
child = this->topLevelItem(i);
child->setExpanded(1);
for (int j = 0; j < child->childCount(); j++)
{
child->child(j)->setExpanded(0);
for (int k = 0; k < child->child(j)->childCount(); k++)
{
child->child(j)->child(k)->setExpanded(0);
}
}
}
}
}
void PreferencesDialog::initCategoryList() {
d->connectionItem = new QTreeWidgetItem(categoryList);
if (MPDConnection::instance()->isConnected())
d->serverItem = new QTreeWidgetItem(d->connectionItem);
d->looknfeelItem = new QTreeWidgetItem(categoryList);
d->looknfeelItem->setExpanded(true);
d->libraryItem = new QTreeWidgetItem(d->looknfeelItem);
d->directoriesItem = new QTreeWidgetItem(d->looknfeelItem);
d->playlistItem = new QTreeWidgetItem(d->looknfeelItem);
d->iconsItem = new QTreeWidgetItem(d->looknfeelItem);
d->stylesItem = new QTreeWidgetItem(d->looknfeelItem);
d->coverArtItem = new QTreeWidgetItem(categoryList);
d->dynamicPlaylistItem = new QTreeWidgetItem(categoryList);
d->localeItem = new QTreeWidgetItem(categoryList);
d->notificationsItem = new QTreeWidgetItem(categoryList);
d->shortcutsItem = new QTreeWidgetItem(categoryList);
d->tagguesserItem = new QTreeWidgetItem(categoryList);
d->trayIconItem = new QTreeWidgetItem(categoryList);
d->trayIconItem->setIcon(0, QIcon(":/icons/qmpdclient16.png"));
d->lastFmItem = new QTreeWidgetItem(categoryList);
d->lastFmItem->setIcon(0, QIcon(":/icons/as.png"));
// Make item-index relations
for (int i = 0, index = 0; i < categoryList->topLevelItemCount(); i++, index++) {
QTreeWidgetItem *item = categoryList->topLevelItem(i);
item->setExpanded(true);
item->setData(0, Qt::UserRole, index);
for (int j = 0; j < item->childCount(); j++)
item->child(j)->setData(0, Qt::UserRole, ++index);
}
}
void QtHelpers::SearchTreeWidget(QTreeWidget *widget, QLineEdit *searchWidget, QString searchString)
{
QList<QTreeWidgetItem*> itemsMatched = widget->findItems(searchWidget->text(), Qt::MatchContains | Qt::MatchRecursive);
for (int i = 0; i < widget->topLevelItemCount(); i++)
QtHelpers::HideAllItems(widget->topLevelItem(i));
if (itemsMatched.count() == 0 || searchString == "")
{
searchWidget->setStyleSheet("color: rgb(255, 1, 1);");
for (int i = 0; i < widget->topLevelItemCount(); i++)
{
QtHelpers::ShowAllItems(widget->topLevelItem(i));
QtHelpers::CollapseAllChildren(widget->topLevelItem(i));
}
return;
}
searchWidget->setStyleSheet("");
// add all the matched ones to the list
for (int i = 0; i < itemsMatched.count(); i++)
{
// show all the item's parents
QTreeWidgetItem *parent = itemsMatched.at(i)->parent();
while (parent != NULL)
{
widget->setItemHidden(parent, false);
parent->setExpanded(true);
parent = parent->parent();
}
// show the item itself
widget->setItemHidden(itemsMatched.at(i), false);
}
}
void MessagesDialog::buildTree( QTreeWidgetItem *parentItem,
vlc_object_t *p_obj )
{
QTreeWidgetItem *item;
if( parentItem )
item = new QTreeWidgetItem( parentItem );
else
item = new QTreeWidgetItem( ui.modulesTree );
char *name = vlc_object_get_name( p_obj );
item->setText( 0, QString("%1%2 (0x%3)")
.arg( qfu( p_obj->psz_object_type ) )
.arg( ( name != NULL )
? QString( " \"%1\"" ).arg( qfu( name ) )
: "" )
.arg( (uintptr_t)p_obj, 0, 16 )
);
free( name );
item->setExpanded( true );
vlc_list_t *l = vlc_list_children( p_obj );
for( int i=0; i < l->i_count; i++ )
buildTree( item, l->p_values[i].p_object );
vlc_list_release( l );
}
/*
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);
}
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();
}
/** Show the database information dialog with all DrugsDB::IDrugEngine report */
void DrugsCentralWidget::showDrugsDatabaseInformation()
{
const DrugsDB::DatabaseInfos *info = drugsBase().actualDatabaseInformation();
if (!info)
return;
QProgressDialog progress(this);
progress.setLabelText(tr("Preparing database and drug engines report"));
progress.setRange(0, 0);
progress.setValue(0);
progress.show();
drugsBase().setConnectionName(DrugsDB::Constants::DB_DRUGS_NAME);
Utils::DatabaseInformationDialog dlg(this);
dlg.setTitle(tkTr(Trans::Constants::DRUGS_DATABASE_INFORMATION));
dlg.setDatabase(drugsBase());
info->toTreeWidget(dlg.getHeaderTreeWidget());
// add drug engines report
QList<DrugsDB::IDrugEngine*> engines = pluginManager()->getObjects<DrugsDB::IDrugEngine>();
QFont bold;
bold.setBold(true);
QFont mono("monospace");
mono.setStyleHint(QFont::Monospace);
foreach(DrugsDB::IDrugEngine *engine, engines) {
QTreeWidgetItem *item = new QTreeWidgetItem(dlg.getHeaderTreeWidget(), QStringList() << tr("Drug engine report: %1").arg(engine->name()));
item->setFont(0, bold);
item->setFirstColumnSpanned(true);
QString reportText = engine->engineDataReport();
QTreeWidgetItem *report = new QTreeWidgetItem(item, QStringList() << reportText);
report->setFont(0, mono);
report->setFirstColumnSpanned(true);
if (!reportText.isEmpty())
item->setExpanded(true);
}
void TabManagerWidget::filterChanged(const QString &filter, bool force)
{
if (force || filter != m_filterText) {
m_filterText = filter.simplified();
ui->treeWidget->itemDelegate()->setProperty("filterText", m_filterText);
if (m_filterText.isEmpty()) {
for (int i = 0; i < ui->treeWidget->topLevelItemCount(); ++i) {
QTreeWidgetItem* parentItem = ui->treeWidget->topLevelItem(i);
for (int j = 0; j < parentItem->childCount(); ++j) {
QTreeWidgetItem* childItem = parentItem->child(j);
childItem->setHidden(false);
}
parentItem->setHidden(false);
parentItem->setExpanded(true);
}
return;
}
const QRegularExpression filterRegExp(filter.simplified().replace(QChar(' '), QLatin1String(".*"))
.append(QLatin1String(".*")).prepend(QLatin1String(".*")),
QRegularExpression::CaseInsensitiveOption);
for (int i = 0; i < ui->treeWidget->topLevelItemCount(); ++i) {
QTreeWidgetItem* parentItem = ui->treeWidget->topLevelItem(i);
int visibleChildCount = 0;
for (int j = 0; j < parentItem->childCount(); ++j) {
QTreeWidgetItem* childItem = parentItem->child(j);
if (childItem->text(0).contains(filterRegExp) || childItem->data(0, UrlRole).toString().simplified().contains(filterRegExp)) {
++visibleChildCount;
childItem->setHidden(false);
}
else {
childItem->setHidden(true);
}
}
if (visibleChildCount == 0) {
parentItem->setHidden(true);
}
else {
parentItem->setHidden(false);
parentItem->setExpanded(true);
}
}
}
}
void K3b::DataMultisessionImportDialog::addMedium( const K3b::Medium& medium )
{
QTreeWidgetItem* mediumItem = new QTreeWidgetItem( d->sessionView );
QFont fnt( mediumItem->font(0) );
fnt.setBold( true );
mediumItem->setText( 0, medium.shortString() );
mediumItem->setFont( 0, fnt );
mediumItem->setIcon( 0, QIcon::fromTheme("media-optical-recordable") );
const K3b::Device::Toc& toc = medium.toc();
QTreeWidgetItem* sessionItem = 0;
int lastSession = 0;
for ( K3b::Device::Toc::const_iterator it = toc.begin(); it != toc.end(); ++it ) {
const K3b::Device::Track& track = *it;
if( track.session() != lastSession ) {
lastSession = track.session();
QString sessionInfo;
if ( track.type() == K3b::Device::Track::TYPE_DATA ) {
K3b::Iso9660 iso( medium.device(), track.firstSector().lba() );
if ( iso.open() ) {
sessionInfo = iso.primaryDescriptor().volumeId;
}
}
else {
int numAudioTracks = 1;
while ( it != toc.end()
&& ( *it ).type() == K3b::Device::Track::TYPE_AUDIO
&& ( *it ).session() == lastSession ) {
++it;
++numAudioTracks;
}
--it;
sessionInfo = i18np("1 audio track", "%1 audio tracks", numAudioTracks );
}
sessionItem = new QTreeWidgetItem( mediumItem, sessionItem );
sessionItem->setText( 0, i18n( "Session %1", lastSession )
+ ( sessionInfo.isEmpty() ? QString() : " (" + sessionInfo + ')' ) );
if ( track.type() == K3b::Device::Track::TYPE_AUDIO )
sessionItem->setIcon( 0, QIcon::fromTheme( "audio-x-generic" ) );
else
sessionItem->setIcon( 0, QIcon::fromTheme( "application-x-tar" ) );
d->sessions.insert( sessionItem, SessionInfo( lastSession, medium.device() ) );
}
}
if( 0 == lastSession ) {
// the medium item in case we have no session info (will always use the last session)
d->sessions.insert( mediumItem, SessionInfo( 0, medium.device() ) );
}
else {
// we have a session item, there is no need to select the medium as a whole
mediumItem->setFlags( mediumItem->flags() ^ Qt::ItemIsSelectable );
}
mediumItem->setExpanded( true );
}
/**
* Handles completion of the calculation algorithm.
*
* @param error If the algorithm exited with an error
*/
void SampleTransmission::algorithmComplete(bool error) {
using namespace Mantid::Kernel;
// Ignore errors
if (error) {
showInformationBox(
"Transmission calculation failed.\nSee Results Log for details.");
return;
}
MatrixWorkspace_sptr ws =
AnalysisDataService::Instance().retrieveWS<MatrixWorkspace>(
"CalculatedSampleTransmission");
// Fill the output table
double scattering = ws->dataY(1)[0];
QTreeWidgetItem *scatteringItem = new QTreeWidgetItem();
scatteringItem->setText(0, "Scattering");
scatteringItem->setText(1, QString::number(scattering));
m_uiForm.twResults->addTopLevelItem(scatteringItem);
QTreeWidgetItem *transmissionItem = new QTreeWidgetItem();
transmissionItem->setText(0, "Transmission");
m_uiForm.twResults->addTopLevelItem(transmissionItem);
transmissionItem->setExpanded(true);
std::vector<double> transmissionData = ws->dataY(0);
Statistics stats = getStatistics(transmissionData);
QMap<QString, double> transmissionStats;
transmissionStats["Min"] = stats.minimum;
transmissionStats["Max"] = stats.maximum;
transmissionStats["Mean"] = stats.mean;
transmissionStats["Median"] = stats.median;
transmissionStats["Std. Dev."] = stats.standard_deviation;
for (auto it = transmissionStats.begin(); it != transmissionStats.end();
++it) {
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setText(0, it.key());
item->setText(1, QString::number(it.value()));
transmissionItem->addChild(item);
}
m_uiForm.twResults->resizeColumnToContents(0);
try {
// Plot transmission curve on preview plot
m_uiForm.ppTransmission->addSpectrum("Transmission",
"CalculatedSampleTransmission", 0);
m_uiForm.ppTransmission->resizeX();
} catch (std::runtime_error &e) {
// PreviewPlot may throw an exception if our workspace has less than two X
// values
showInformationBox(
QString::fromStdString("Unable to plot CalculatedSampleTransmission: " +
std::string(e.what())));
}
}
