HierarchyTreeControlMimeData::HierarchyTreeControlMimeData(const QList<QTreeWidgetItem*> items)
{
	for (QList<QTreeWidgetItem*>::const_iterator iter = items.begin(); iter != items.end(); ++iter)
	{
		QTreeWidgetItem* item = (*iter);
		QVariant data = item->data(ITEM_ID);
		HierarchyTreeNode::HIERARCHYTREENODEID id = data.toInt();
		
		Logger::Debug("HierarchyTreeNode::HIERARCHYTREENODEID %d", id);
		
		HierarchyTreeNode::HIERARCHYTREENODESIDLIST::iterator it = std::find(this->items.begin(), this->items.end(), id);
		if (it == this->items.end())
			this->items.push_back(id);
	}
}
Example #2
0
void EditDrumset::updateList2()
      {
      for (int i = 0; i < pitchList->topLevelItemCount(); ++i) {
            QTreeWidgetItem* item = pitchList->topLevelItem(i);
            int pitch = item->data(0, Qt::UserRole).toInt();
            if (nDrumset.shortcut(pitch) == 0)
                  item->setText(COL_SHORTCUT, "");
            else {
                  QString s(QChar(nDrumset.shortcut(pitch)));
                  item->setText(COL_SHORTCUT, s);
                  }
            item->setText(COL_NAME, qApp->translate("drumset", qPrintable(nDrumset.name(pitch))));
            item->setData(0, Qt::UserRole, pitch);
            }
      }
Example #3
0
void InfoTreeWidget::UpdateTrackVolumeAnnotation(Layer *layer, const QVariantMap &info)
{
  for (int i = 0; i < this->topLevelItemCount(); i++)
  {
    QTreeWidgetItem* item = this->topLevelItem(i);
    if (item)
    {
      QVariantMap map = item->data(1, Qt::UserRole).toMap();
      if (map.contains("Object") && map["Object"].value<QObject*>() == layer)
      {
        item->setText(1, QString("%1 \t%2").arg(info["label"].toInt()).arg(info["name"].toString()));
      }
    }
  }
}
Example #4
0
void LibraryTreeWidget::excludeFromExecution(bool checked)
{
    if (selectedItems().empty() == true)
        return;

    QTreeWidgetItem* item = selectedItems()[0];

    QMap<QString, QVariant> data = item->data(0, Qt::UserRole).toMap();
    data["excludeFromExecution"] = checked;
    item->setData(0, Qt::UserRole, data);

    item->setIcon(0, IconLibrary::instance().icon(0, checked ? "lua with stop" : "lua"));

    dependencyGraph_.setExcludeFromExecution(data["filename"].toString(), checked);
}
Example #5
0
VCXYPadPreset *VCXYPadProperties::getSelectedPreset()
{
    if (m_presetsTree->selectedItems().isEmpty())
        return NULL;

    QTreeWidgetItem* item = m_presetsTree->selectedItems().first();
    if (item != NULL)
    {
        quint8 presetID = item->data(0, Qt::UserRole).toUInt();
        foreach(VCXYPadPreset* preset, m_presetList)
        {
            if (preset->m_id == presetID)
                return preset;
        }
    }
void EditorPage::updateTextFormatDisplay()
{
    QTreeWidgetItem *item = ui->textFormats->currentItem();
    bool canEdit = item && item->data(0, TextFormatConfigKeyRole).isValid();
    if (!canEdit)
        return;

    QTextCharFormat format = constructTextFormat();
    item->setData( 0, TextFormatRole, QVariant::fromValue(format) );

    if (item != mCommonTextFormatItem)
        updateTextFormatDisplay( item );
    else
        updateTextFormatDisplayCommons();
}
Example #7
0
  /**
   * Get the QTreeWidgetItem associated with the given undo command (work order). Returns NULL if
   *   none found or given NULL.
   *
   * @param undoCommand A work order
   * @return The QTreeWidgetItem that represents (is associated with) the undoCommand
   */
  QTreeWidgetItem *HistoryTreeWidget::undoCommandToTreeItem(const QUndoCommand *undoCommand) {
    QTreeWidgetItem *result = NULL;

    if (undoCommand) {
      for (int i = invisibleRootItem()->childCount() - 1; !result && i >= 0; i--) {
        QTreeWidgetItem *item = invisibleRootItem()->child(i);
        WorkOrder *workOrder = item->data(0, Qt::UserRole).value<WorkOrder *>();

        if (undoCommand == workOrder)
          result = item;
      }
    }

    return result;
  }
Example #8
0
QSet <quint32> VCSpeedDialProperties::functions() const
{
    QSet <quint32> set;
    for (int i = 0; i < m_tree->topLevelItemCount(); i++)
    {
        QTreeWidgetItem* item = m_tree->topLevelItem(i);
        Q_ASSERT(item != NULL);

        QVariant var = item->data(COL_NAME, PROP_ID);
        if (var.isValid() == true)
            set << var.toUInt();
    }

    return set;
}
Example #9
0
QTreeWidgetItem* EFXEditor::fixtureItem(EFXFixture* ef)
{
    QTreeWidgetItemIterator it(m_tree);
    while (*it != NULL)
    {
        QTreeWidgetItem* item = *it;
        EFXFixture* ef_item = reinterpret_cast<EFXFixture*>
                              (item->data(0, Qt::UserRole).toULongLong());
        if (ef_item == ef)
            return item;
        ++it;
    }

    return NULL;
}
void ProtobufTree::expandMessages(QTreeWidgetItem* item) {
    if (!item) {
        item = invisibleRootItem();
    }

    expandItem(item);

    for (int i = 0; i < item->childCount(); ++i) {
        QTreeWidgetItem* child = item->child(i);

        if (child->data(Column_Tag, IsMessageRole).toBool()) {
            expandMessages(child);
        }
    }
}
Example #11
0
void LibraryWidget::closeLibrary(const QUrl &projectThingUrl)
{
    int toplevelItems = ui->treeWidget->topLevelItemCount();

    for(int i=1; i <= toplevelItems; i++) {
        QTreeWidgetItem *root = ui->treeWidget->topLevelItem(i);

        QUrl openProject = (root->data(0,BibGlobals::Role_ProjectThing).toUrl());
        if(openProject == projectThingUrl) {
            QTreeWidgetItem *closedItem = ui->treeWidget->takeTopLevelItem(i);
            delete closedItem;
            break;
        }
    }
}
Example #12
0
void CheatEditorWindow::listChanged() {
  QList<QTreeWidgetItem*> items = list->selectedItems();
  if(items.count() > 0) {
    QTreeWidgetItem *item = items[0];
    unsigned n = item->data(0, Qt::UserRole).toUInt();

    SNES::Cheat::cheat_t code;
    SNES::cheat.get(n, code);

    descEdit->setText(utf8() << code.desc);
    codeEdit->setText(utf8() << code.code);
  }

  syncUi();
}
Example #13
0
	void LinkList::onEditButtonClicked()
	{
		QTreeWidgetItem *item =
			linkTree->currentItem();
		if( item == NULL )
			return;

		bool ok;
		uint32 id = item->data( 3, Qt::UserRole ).toUInt( &ok );
		if( !ok )
			return;

		linkEditor->setLinkId( id );
		linkEditor->show();
	}
Example #14
0
void TreeWidget::moveToMostActiveItem()
{
    QTreeWidgetItem* mostActive = 0;
    QTreeWidgetItemIterator it(this, QTreeWidgetItemIterator::Unselected);
    while (*it) {
        QTreeWidgetItem* item = *it;

        if (d.highlightedItems.contains(item)) {
            // we found a channel hilight or PM to us
            setCurrentItem(item);
            return;
        }

        // as a backup, store the most active window with any sort of activity
        const int badge = item->data(1, TreeRole::Badge).toInt();
        if (badge > 0 && (!mostActive || mostActive->data(1, TreeRole::Badge).toInt() < badge))
            mostActive = item;

        it++;
    }

    if (mostActive)
        setCurrentItem(mostActive);
}
void QgsVectorGradientColorRampV2Dialog::updatePreview()
{
  // update ramp stops from the tree widget
  QgsGradientStopsList stops;
  if ( groupStops->isChecked() )
  {
    int count = treeStops->topLevelItemCount();
    for ( int i = 0; i < count; i++ )
    {
      QTreeWidgetItem* item = treeStops->topLevelItem( i );
      double offset = item->data( 0, StopOffsetRole ).toDouble();
      QColor color = item->data( 0, StopColorRole ).value<QColor>();
      stops.append( QgsGradientStop( offset, color ) );
    }
  }
  mRamp->setStops( stops );

  // generate the preview
  QSize size( 300, 40 );
  lblPreview->setPixmap( QgsSymbolLayerV2Utils::colorRampPreviewPixmap( mRamp, size ) );

  btnColor1->setColor( mRamp->color1() );
  btnColor2->setColor( mRamp->color2() );
}
void HierarchyTreeControl::HandleDragMoveControlMimeData(QDragMoveEvent *event, const ControlMimeData* /*mimeData*/)
{
    DropIndicatorPosition position = dropIndicatorPosition();
    Logger::Warning("POSITION TYPE^ %i", position);

	// Where we are in tree?
	QTreeWidgetItem* item = itemAt(event->pos());
	if (!item)
	{
		HierarchyTreeController::Instance()->ResetSelectedControl();
		return;
	}

	HierarchyTreeNode::HIERARCHYTREENODEID insertInto = HierarchyTreeNode::HIERARCHYTREENODEID_EMPTY;
	QVariant data = item->data(ITEM_ID);
	insertInto = data.toInt();
	
	// Handle specific types of nodes.
	HierarchyTreeNode* nodeToInsertControlTo = HierarchyTreeController::Instance()->GetTree().GetNode(insertInto);
	if (dynamic_cast<HierarchyTreePlatformNode*>(nodeToInsertControlTo) ||
		dynamic_cast<HierarchyTreeAggregatorControlNode*>(nodeToInsertControlTo))
	{
		// Don't allow to drop the controls directly to Platform or Aggregator.
		HierarchyTreeController::Instance()->ResetSelectedControl();
		return;
	}
	
	// Expand the items while dragging control on them.
	if (!item->isExpanded())
	{
		item->setExpanded(true);
	}

	scrollTo(indexAt(event->pos()));

	HierarchyTreeControlNode* controlNode = dynamic_cast<HierarchyTreeControlNode*>(nodeToInsertControlTo);
	if (controlNode)
	{
		// Don't reselect the same control, if it is already selected.
		if (!HierarchyTreeController::Instance()->IsControlSelected(controlNode))
		{
			HierarchyTreeController::Instance()->ResetSelectedControl();
			HierarchyTreeController::Instance()->SelectControl(controlNode);
		}
	}

	event->accept();
}
Example #17
0
void ProfileDialog::editingFinished()
{
    QTreeWidgetItem *item = pd_ui_->profileTreeWidget->currentItem();

    if (item) {
        profile_def *profile = (profile_def *) VariantPointer<GList>::asPtr(item->data(0, Qt::UserRole))->data;
        if (item->text(0).compare(profile->name) != 0) {
            g_free(profile->name);
            profile->name = qstring_strdup(item->text(0));
            if (profile->status == PROF_STAT_EXISTS) {
                profile->status = PROF_STAT_CHANGED;
            }
        }
    }
    updateWidgets();
}
Example #18
0
void Debugger_Disasm::on_breakpointsList_customContextMenuRequested(const QPoint &pos)
{
	QTreeWidgetItem* item = ui->breakpointsList->itemAt(pos);
	if(item)
	{
		breakpointAddr = item->data(0,Qt::UserRole).toInt();

		QMenu menu(this);

		QAction *removeBP = new QAction(tr("Remove breakpoint"), this);
		connect(removeBP, SIGNAL(triggered()), this, SLOT(RemoveBreakpoint()));
		menu.addAction(removeBP);

		menu.exec( ui->breakpointsList->mapToGlobal(pos));
	}
}
void LibraryEditDlg::removeSignatures()
{
   QList<QTreeWidgetItem*> items = mpTree->selectedItems();
   QListIterator<QTreeWidgetItem*> it(items);
   while (it.hasNext())
   {
      QTreeWidgetItem* pItem = it.next();
      QVariant variant = pItem->data(0, Qt::UserRole);
      if (variant.isValid())
      {
         VERIFYNR(variant.value<Signature*>()->detach(SIGNAL_NAME(Subject, Deleted),
            Slot(this, &LibraryEditDlg::signatureDeleted)));
      }
      delete pItem;
   }
}
Example #20
0
QList<QLCChannel *> AddChannelsDialog::getModeChannelsList()
{
    QList<QLCChannel *> retList;
    for (int i = 0; i < m_modeTree->topLevelItemCount(); i++)
    {
        QTreeWidgetItem *item = m_modeTree->topLevelItem(i);
        if (item == NULL)
            continue;
        int idx = item->data(0, Qt::UserRole).toInt();
        if (idx < 0 || idx >= m_channelsList.count())
            continue;
        QLCChannel *ch = m_channelsList.at(idx);
        retList.append(ch);
    }
    return retList;
}
Example #21
0
void ChatLobbyWidget::unsubscribeItem()
{
	QTreeWidgetItem *item = lobbyTreeWidget->currentItem();
	if (item == NULL && item->type() != TYPE_LOBBY) {
		return;
	}

	const ChatLobbyId id = item->data(COLUMN_DATA, ROLE_ID).toULongLong();

	std::string vpeer_id;
	if (rsMsgs->getVirtualPeerId(id, vpeer_id)) {
		ChatDialog::closeChat(vpeer_id);
	}

	rsMsgs->unsubscribeChatLobby(id);
}
Example #22
0
void VCXYPadProperties::selectItemOnPresetsTree(quint8 presetId)
{
    m_presetsTree->blockSignals(true);

    for (int i = 0; i < m_presetsTree->topLevelItemCount(); ++i)
    {
        QTreeWidgetItem* treeItem = m_presetsTree->topLevelItem(i);
        if (treeItem->data(0, Qt::UserRole).toUInt() == presetId)
        {
            treeItem->setSelected(true);
            break;
        }
    }

    m_presetsTree->blockSignals(false);
}
Example #23
0
/** Saves the changes on this page */
bool SoundPage::save(QString &/*errmsg*/)
{
	QTreeWidgetItemIterator itemIterator(ui.eventTreeWidget);
	QTreeWidgetItem *item = NULL;
	while ((item = *itemIterator) != NULL) {
		itemIterator++;

		if (item->type() == TYPE_ITEM) {
			const QString event = item->data(COLUMN_DATA, ROLE_EVENT).toString();
			soundManager->setEventEnabled(event, item->checkState(COLUMN_NAME) == Qt::Checked);
			soundManager->setEventFilename(event, item->text(COLUMN_FILENAME));
		}
	}

	return true;
}
/*! \brief Remove the selected entity node
*/
void EntitiesTreeWidget::onRemove()
{
    QTreeWidgetItem *item = currentItem();


    if(!item){
        return;
    }



    if(QMessageBox::question(this,"Removing","Are you sure to remove this item?") == QMessageBox::Yes){

        if(item->parent() == applicationNode){
            if(item->data(0,Qt::UserRole)  == yarp::manager::APPLICATION){
                yarp::manager::Application *app = (yarp::manager::Application*)item->data(0,Qt::UserRole + 1).toLongLong();
                if(app){
                    QString appName = item->text(0);

                    removeApplication(appName);
                }

            }
        }else
            if(item->parent() == resourcesNode){
                if(item->data(0,Qt::UserRole)  == yarp::manager::RESOURCE){
                    yarp::manager::Computer *res = (yarp::manager::Computer*)item->data(0,Qt::UserRole + 1).toLongLong();
                    if(res){
                        QString resName = item->text(0);

                        removeResource(resName);
                    }
                }
            }else
            if(item->parent() == modulesNode){
                if(item->data(0,Qt::UserRole)  == yarp::manager::MODULE){
                    yarp::manager::Module *mod = (yarp::manager::Module*)item->data(0,Qt::UserRole + 1).toLongLong();
                    if(mod){
                        QString modName = item->text(0);

                        removeModule(modName);
                    }
                }
            }

            while(item->childCount()>0){
                delete item->takeChild(0);
            }

            if(item->parent()){
                int index = item->parent()->indexOfChild(item);
                delete item->parent()->takeChild(index);
            }
    }
}
Example #25
0
void InputSettingsWindow::unassignGroup() {
  QTreeWidgetItem *item = list->currentItem();
  if(!item) return;
  item = item->child(0);
  if(!item) return;
  signed index = item->data(0, Qt::UserRole).toInt();
  if(index == -1) return;

  MappedInput *input = inputTable[index];
  InputGroup &group = *(input->parent);
  for(unsigned i = 0; i < group.size(); i++) {
    group[i]->name = "None";
  }
  mapper().bind();
  updateList();
}
void DeviceFilterGUIDialog::on_showOnlyInstalledCheckBox_toggled(bool checked)
{
	for (int i = 0; i < ui->treeWidget->topLevelItemCount(); i++)
	{
		QTreeWidgetItem* groupItem = ui->treeWidget->topLevelItem(i);
		for (int j = 0; j < groupItem->childCount(); j++)
		{
			QTreeWidgetItem* item = groupItem->child(j);
			const DeviceAPOInfo* apoInfo = item->data(0, Qt::UserRole).value<const DeviceAPOInfo*>();
			item->setHidden(item->checkState(0) != Qt::Checked && !apoInfo->isInstalled && checked);
		}
	}

	for (int i = 0; i < ui->treeWidget->columnCount(); i++)
		ui->treeWidget->resizeColumnToContents(i);
}
Example #27
0
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);
            }
        }
    }
}
Example #28
0
void JBlockerMainWindow::slt_showInboxMessageByService(QTreeWidgetItem* item, int column)
{
    qDebug() << "+ " << __PRETTY_FUNCTION__;

    QTreeWidgetItem* parentItem = item->parent();
    /* Check if clicked item is child item or parent item */
    if(parentItem && column == 0)
    {
        /* Get parent name */
        QString parentName = parentItem->data(0, MessageIdRole).toString();
        QList<QMessage>* msgList = p_messageCore->getMessageList(parentName);
        int index = parentItem->indexOfChild(item);
        QMessage msg = msgList->at(index);
        /* Show message content */
        emit sig_showMessageBox(msg, p_messageCore->getCurrentAccountType());
    }
}
Example #29
0
void ProfileDialog::on_deleteToolButton_clicked()
{
    QTreeWidgetItem *item = pd_ui_->profileTreeWidget->currentItem();

    if (item) {
        GList *fl_entry = item->data(0, Qt::UserRole).value<GList *>();
        profile_def *profile = (profile_def *) fl_entry->data;
        if (profile->is_global || profile->status == PROF_STAT_DEFAULT) {
            return;
        }
        remove_from_profile_list(fl_entry);
        delete item;

        // Select the default
        pd_ui_->profileTreeWidget->setCurrentItem(pd_ui_->profileTreeWidget->topLevelItem(0));
    }
}
Example #30
0
void DlgCustomKeyboardImp::onRemoveMacroAction(const QByteArray& macro)
{
    QVariant data = categoryBox->itemData(categoryBox->currentIndex(), Qt::UserRole);
    QString group = data.toString();
    if (group == QLatin1String("Macros"))
    {
        for (int i=0; i<commandTreeWidget->topLevelItemCount(); i++) {
            QTreeWidgetItem* item = commandTreeWidget->topLevelItem(i);
            QByteArray command = item->data(1, Qt::UserRole).toByteArray();
            if (command == macro) {
                commandTreeWidget->takeTopLevelItem(i);
                delete item;
                break;
            }
        }
    }
}