void TabStopDialog::updateButtons(QTreeWidgetItem *item)
{
QTreeWidgetItem *root = m_widgetTree->invisibleRootItem();
m_btnUp->setEnabled(item && (root->indexOfChild(item) > 0 && m_widgetTree->isEnabled()
/*&& (item->itemAbove()->parent() == item->parent()))*/));
m_btnDown->setEnabled(item && root->indexOfChild(item) < (root->childCount() - 1) && m_widgetTree->isEnabled());
}
void ColorDialog::favoritesItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
{
Q_UNUSED(previous);
QTreeWidgetItem *root = ui_->listFavorites->invisibleRootItem();
if (!current) {
ui_->buttonRemove->setEnabled(false);
ui_->buttonMoveUp->setEnabled(false);
ui_->buttonMoveDown->setEnabled(false);
return;
} else {
ui_->buttonRemove->setEnabled(true);
if (root->indexOfChild(current) != 0)
ui_->buttonMoveUp->setEnabled(true);
else
ui_->buttonMoveUp->setEnabled(false);
if (root->indexOfChild(current) != root->childCount() - 1)
ui_->buttonMoveDown->setEnabled(true);
else
ui_->buttonMoveDown->setEnabled(false);
}
int cid = current->data(0, Qt::UserRole).toInt();
ui_->listColors->setCurrentItem(ui_->listColors->invisibleRootItem()->child(colorMap_[cid]));
}
void QTreeWidgetItemIteratorPrivate::ensureValidIterator(const QTreeWidgetItem *itemToBeRemoved)
{
Q_Q(QTreeWidgetItemIterator);
Q_ASSERT(itemToBeRemoved);
if (!q->current) return;
QTreeWidgetItem *nextItem = q->current;
// Do not walk to the ancestor to find the other item if they have the same parent.
if (nextItem->parent() != itemToBeRemoved->parent()) {
while (nextItem->parent() && nextItem != itemToBeRemoved) {
nextItem = nextItem->parent();
}
}
// If the item to be removed is an ancestor of the current iterator item,
// we need to adjust the iterator.
if (nextItem == itemToBeRemoved) {
QTreeWidgetItem *parent = nextItem;
nextItem = 0;
while (parent && !nextItem) {
nextItem = nextSibling(parent);
parent = parent->parent();
}
if (nextItem) {
// Ooooh... Set the iterator to the next valid item
*q = QTreeWidgetItemIterator(nextItem, q->flags);
if (!(q->matchesFlags(nextItem))) ++(*q);
} else {
// set it to null.
q->current = 0;
m_parentIndex.clear();
return;
}
}
if (nextItem->parent() == itemToBeRemoved->parent()) {
// They have the same parent, i.e. we have to adjust the m_currentIndex member of the iterator
// if the deleted item is to the left of the nextItem.
QTreeWidgetItem *par = itemToBeRemoved->parent(); // We know they both have the same parent.
QTreeWidget *tw = itemToBeRemoved->treeWidget(); // ..and widget
int indexOfItemToBeRemoved = par ? par->indexOfChild(const_cast<QTreeWidgetItem *>(itemToBeRemoved))
: tw->indexOfTopLevelItem(const_cast<QTreeWidgetItem *>(itemToBeRemoved));
int indexOfNextItem = par ? par->indexOfChild(nextItem) : tw->indexOfTopLevelItem(nextItem);
if (indexOfItemToBeRemoved <= indexOfNextItem) {
// A sibling to the left of us was deleted, adjust the m_currentIndex member of the iterator.
// Note that the m_currentIndex will be wrong until the item is actually removed!
m_currentIndex--;
}
}
}
void BoincTree::removeTreeItems(InfoBoinc::Session::IdType id, QList<QTreeWidgetItem *> items)
{
QTreeWidgetItem *sessionItem = m_sessionItems[id];
m_tree->setUpdatesEnabled(false);
foreach (QTreeWidgetItem *item, items) {
sessionItem->takeChild(sessionItem->indexOfChild(item));
}
void
TransitionEditorWindow::on_equationsTree_itemClicked(QTreeWidgetItem* item, int /*column*/)
{
qDebug("on_equationsTree_itemClicked");
if (model_ == nullptr) return;
if (transition_ == nullptr) return;
if (item == nullptr) return;
QTreeWidgetItem* parent = item->parent();
if (parent == nullptr) { // root item
ui_->formulaTextEdit->clear();
return;
}
int parentIndex = ui_->equationsTree->indexOfTopLevelItem(parent);
int index = parent->indexOfChild(item);
const auto& equation = model_->equationGroupList()[parentIndex].equationList[index];
// Set timeExpression for the current point.
QTableWidgetItem* currentItem = ui_->pointsTable->currentItem();
if (currentItem == nullptr) return;
int row = currentItem->row();
if (pointList_[row].timeExpression.lock() != equation) {
pointList_[row].timeExpression = equation;
updateTransition();
}
}
void TreeWidgetEditor::on_moveItemLeftButton_clicked()
{
QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
if (!curItem)
return;
QTreeWidgetItem *parentItem = curItem->parent();
if (!parentItem)
return;
m_updating = true;
QTreeWidgetItem *takenItem = parentItem->takeChild(parentItem->indexOfChild(curItem));
if (parentItem->parent()) {
int idx = parentItem->parent()->indexOfChild(parentItem);
parentItem->parent()->insertChild(idx, takenItem);
} else {
int idx = ui.treeWidget->indexOfTopLevelItem(parentItem);
ui.treeWidget->insertTopLevelItem(idx, takenItem);
}
ui.treeWidget->setCurrentItem(takenItem, ui.listWidget->currentRow());
m_updating = false;
updateEditor();
}
int QTreeWidgetItemProto::indexOfChild(QTreeWidgetItem *child) const
{
QTreeWidgetItem *item = qscriptvalue_cast<QTreeWidgetItem*>(thisObject());
if (item)
return item->indexOfChild(child);
return -1;
}
/*
The user has triggered the action to remove a file from the project.
Grab the file name and signal ProjectInfo to make the change.
*/
void FileBrowser::onRemoveRequest()
{
QString filepath = currentItem()->text(FILENAME_COLUMN);
QTreeWidgetItem *top = topLevelItem(0);
delete top->takeChild(top->indexOfChild(currentItem()));
emit removeFileRequest(filepath);
}
void Parametertuner::moveSelection(int dir)
{
QTreeWidgetItem* thisItem = getSelectedItem();
if (!thisItem)
{
m_ui.parameter_root_widget->topLevelItem(0)->setSelected(true);
return;
}
QTreeWidgetItem* parent = thisItem->parent();
QTreeWidgetItem* nextItem;
if (!parent)
{
parent = m_ui.parameter_root_widget->invisibleRootItem();
}
int thisItemIndex = parent->indexOfChild(thisItem);
if (thisItem->isExpanded() && dir == DOWN)
{
nextItem = thisItem->child(0);
updateSelection(thisItem, nextItem);
return;
}
else if (!parent->child(thisItemIndex + dir))
{
updateSelection(thisItem, parent);
return;
}
else
{
nextItem = parent->child(thisItemIndex + dir);
updateSelection(thisItem, nextItem);
return;
}
}
void InstrumentWizard::on_downButton_clicked()
{
QList<QTreeWidgetItem*> wi = partiturList->selectedItems();
if (wi.isEmpty())
return;
QTreeWidgetItem* item = wi.front();
if (item->type() == PART_LIST_ITEM) {
bool isExpanded = partiturList->isItemExpanded(item);
int idx = partiturList->indexOfTopLevelItem(item);
int n = partiturList->topLevelItemCount();
if (idx < (n-1)) {
partiturList->selectionModel()->clear();
QTreeWidgetItem* item = partiturList->takeTopLevelItem(idx);
partiturList->insertTopLevelItem(idx+1, item);
partiturList->setItemExpanded(item, isExpanded);
partiturList->setItemSelected(item, true);
}
}
else {
QTreeWidgetItem* parent = item->parent();
int idx = parent->indexOfChild(item);
int n = parent->childCount();
if (idx < (n-1)) {
partiturList->selectionModel()->clear();
QTreeWidgetItem* item = parent->takeChild(idx);
parent->insertChild(idx+1, item);
partiturList->setItemSelected(item, true);
}
}
}
void InstrumentWizard::on_removeButton_clicked()
{
QList<QTreeWidgetItem*> wi = partiturList->selectedItems();
if (wi.isEmpty())
return;
QTreeWidgetItem* item = wi.front();
QTreeWidgetItem* parent = item->parent();
if (parent) {
if (((StaffListItem*)item)->op == ITEM_ADD) {
if (parent->childCount() == 1) {
partiturList->takeTopLevelItem(partiturList->indexOfTopLevelItem(parent));
delete parent;
}
else {
parent->takeChild(parent->indexOfChild(item));
delete item;
}
}
else {
((StaffListItem*)item)->op = ITEM_DELETE;
partiturList->setItemHidden(item, true);
}
}
else {
if (((PartListItem*)item)->op == ITEM_ADD)
delete item;
else {
((PartListItem*)item)->op = ITEM_DELETE;
partiturList->setItemHidden(item, true);
}
}
partiturList->clearSelection();
emit completeChanged(partiturList->topLevelItemCount() > 0);
}
void SummaryTree::addTestCases()
{
QTreeWidgetItem *curItem = currentItem();
if (indexOfTopLevelItem(curItem) == -1)
curItem = curItem->parent();
int index = indexOfTopLevelItem(curItem);
Task *curTask = curContest->getTask(index);
AddTestCasesWizard *wizard = new AddTestCasesWizard(this);
wizard->setSettings(settings, curTask->getTaskType() == Task::Traditional);
if (wizard->exec() == QDialog::Accepted) {
QList<QStringList> inputFiles = wizard->getMatchedInputFiles();
QList<QStringList> outputFiles = wizard->getMatchedOutputFiles();
for (int i = 0; i < inputFiles.size(); i ++) {
addTestCase();
QTreeWidgetItem *curItem = currentItem();
QTreeWidgetItem *parentItem = curItem->parent();
int taskIndex = indexOfTopLevelItem(parentItem);
int testCaseIndex = parentItem->indexOfChild(curItem);
Task *curTask = curContest->getTask(taskIndex);
TestCase *curTestCase = curTask->getTestCase(testCaseIndex);
curTestCase->setFullScore(wizard->getFullScore());
curTestCase->setTimeLimit(wizard->getTimeLimit());
curTestCase->setMemoryLimit(wizard->getMemoryLimit());
for (int j = 0; j < inputFiles[i].size(); j ++)
curTestCase->addSingleCase(inputFiles[i][j], outputFiles[i][j]);
setCurrentItem(parentItem);
setCurrentItem(curItem);
}
}
delete wizard;
}
/** Removes an action */
void DlgCustomToolbars::on_moveActionLeftButton_clicked()
{
QTreeWidgetItem* item = toolbarTreeWidget->currentItem();
if (item && item->parent() && toolbarTreeWidget->isItemSelected(item)) {
QTreeWidgetItem* parent = item->parent();
int index = parent->indexOfChild(item);
parent->takeChild(index);
// In case a separator should be moved we have to count the separators
// which come before this one.
// This is needed so that we can distinguish in removeCustomCommand
// which separator it is.
QByteArray data = item->data(0, Qt::UserRole).toByteArray();
if (data == "Separator") {
int countSep = 1;
for (int i=0; i<index-1; i++) {
QByteArray d = parent->child(i)->data(0, Qt::UserRole).toByteArray();
if (d == "Separator") {
countSep++;
}
}
data += QByteArray::number(countSep);
}
removeCustomCommand(parent->text(0), data);
delete item;
}
QVariant data = workbenchBox->itemData(workbenchBox->currentIndex(), Qt::UserRole);
QString workbench = data.toString();
exportCustomToolbars(workbench.toLatin1());
}
void TreeWidget::swapItems(QTreeWidgetItem* source, QTreeWidgetItem* target)
{
QTreeWidgetItem* parent = source->parent();
if (!parent)
parent = invisibleRootItem();
const bool se = source->isExpanded();
const bool ss = source->isFirstColumnSpanned();
const bool te = target->isExpanded();
const bool ts = target->isFirstColumnSpanned();
const int idx = parent->indexOfChild(target);
parent->takeChild(parent->indexOfChild(source));
parent->insertChild(idx, source);
source->setExpanded(se);
source->setFirstColumnSpanned(ss);
target->setExpanded(te);
target->setFirstColumnSpanned(ts);
}
int QcTreeWidget::indexOfItem( const QcTreeWidget::ItemPtr & item )
{
if( !item ) return -1;
QTreeWidgetItem *parent = item->parent();
if( parent )
return parent->indexOfChild( item );
else
return indexOfTopLevelItem( item );
}
void QMwStructuresWidget::ContextMenuDeleteTriggered()
{
QTreeWidgetItem *contextItemParent = this->GetItemParent(this->contextMenuItem);
MwEntitySet *contextParentSet = (MwEntitySet*)this->GetMwResourceFromItem(contextItemParent);
int contextItemIndex = contextItemParent->indexOfChild(this->contextMenuItem);
contextParentSet->references.RemoveAt(contextItemIndex);
contextItemParent->removeChild(this->contextMenuItem);
}
void TestRegressionWindow::testerExited(int /* exitCode */, QProcess::ExitStatus exitStatus)
{
assert(m_activeProcess != 0);
assert(m_activeTreeItem != 0);
if(exitStatus == QProcess::CrashExit) // Special case: crash!
{
QTreeWidgetItem *useItem = m_activeTreeItem;
if(m_testCounter >= 0 || m_runCounter > 0) // Single-tests mode invoked on a directory OR All-test-mode
{
QTreeWidgetItem *parent = useItem->parent();
assert(parent != 0);
useItem = parent->child(parent->indexOfChild(useItem) + 1);
assert(useItem != 0);
}
// Reflect crashed test...
updateItemStatus(Crash, useItem, QString());
}
if(m_testCounter >= 0) // All-tests mode
m_ui.progressBar->setValue(m_ui.progressBar->maximum());
// Eventually save log output...
if(!m_saveLogUrl.isEmpty())
{
// We should close our written log with </body></html>.
m_processingQueue.enqueue(QString::fromLatin1("\n</body>\n</html>"));
if(!m_justProcessingQueue)
{
m_justProcessingQueue = true;
QTimer::singleShot(50, this, SLOT(processQueue()));
}
}
// Cleanup gui...
m_ui.saveLogButton->setEnabled(true);
m_ui.actionRun_tests->setEnabled(true);
m_ui.pauseContinueButton->setEnabled(false);
// Check if there is already an output/index.html present...
loadOutputHTML();
// Cleanup data..
delete m_activeProcess;
m_activeProcess = 0;
m_runCounter = 0;
m_testCounter = 0;
m_activeTreeItem = 0;
}
// Drag-and-drop target method...
QTreeWidgetItem *qtractorFileListView::dropItem (
QTreeWidgetItem *pDropItem, QTreeWidgetItem *pDragItem, bool bOutdent )
{
// We must be dropping something...
if (pDragItem == NULL)
return NULL;
// Take the item from list...
int iItem;
QTreeWidgetItem *pParentItem = pDragItem->parent();
if (pParentItem) {
iItem = pParentItem->indexOfChild(pDragItem);
if (iItem >= 0)
pDragItem = pParentItem->takeChild(iItem);
} else {
iItem = QTreeWidget::indexOfTopLevelItem(pDragItem);
if (iItem >= 0)
pDragItem = QTreeWidget::takeTopLevelItem(iItem);
}
// Insert it back...
if (pDropItem) {
if (pDropItem->type() == GroupItem && !bOutdent) {
pDropItem->insertChild(0, pDragItem);
} else {
pParentItem = pDropItem->parent();
if (pParentItem) {
iItem = pParentItem->indexOfChild(pDropItem);
pParentItem->insertChild(iItem + 1, pDragItem);
} else {
iItem = QTreeWidget::indexOfTopLevelItem(pDropItem);
QTreeWidget::insertTopLevelItem(iItem + 1, pDragItem);
}
}
} else {
QTreeWidget::addTopLevelItem(pDragItem);
}
// Return the new item...
return pDragItem;
}
void SummaryTree::deleteTestCase()
{
QTreeWidgetItem *curItem = currentItem();
QTreeWidgetItem *parentItem = curItem->parent();
int taskIndex = indexOfTopLevelItem(parentItem);
int testCaseIndex = parentItem->indexOfChild(curItem);
Task *curTask = curContest->getTask(taskIndex);
delete curItem;
curTask->deleteTestCase(testCaseIndex);
for (int i = 0; i < parentItem->childCount(); i ++)
parentItem->child(i)->setText(0, tr("Test Case #%1").arg(i + 1));
}
void GlobalSearchSettingsPage::CurrentProviderChanged(QTreeWidgetItem* item) {
if (!item) return;
QTreeWidgetItem* root = ui_->sources->invisibleRootItem();
SearchProvider* provider =
item->data(0, Qt::UserRole).value<SearchProvider*>();
const int row = root->indexOfChild(item);
ui_->up->setEnabled(row != 0);
ui_->down->setEnabled(row != root->childCount() - 1);
ui_->configure->setEnabled(provider->can_show_config());
}
void TabStopDialog::moveItemDown()
{
QTreeWidgetItem *selected = m_widgetTree->selectedItem();
if (!selected)
return;
// we assume there is flat list
QTreeWidgetItem *root = m_widgetTree->invisibleRootItem();
const int selectedIndex = root->indexOfChild(selected);
if (selectedIndex >= (root->childCount() - 1))
return; // no place to move
root->takeChild(selectedIndex);
root->insertChild(selectedIndex + 1, selected);
updateButtons(selected);
}
void TabStopDialog::moveItemUp()
{
QTreeWidgetItem *selected = d->widgetTree->selectedItem();
if (!selected)
return;
// we assume there is flat list
QTreeWidgetItem *root = d->widgetTree->invisibleRootItem();
const int selectedIndex = root->indexOfChild(selected);
if (selectedIndex < 1)
return; // no place to move
root->takeChild(selectedIndex);
root->insertChild(selectedIndex - 1, selected);
updateButtons(selected);
}
void SettingsDialog::removeRepository()
{
QTreeWidgetItem *item = m_ui->m_repositoriesView->currentItem();
if (item && !m_rootItems.contains(item)) {
QTreeWidgetItem *parent = item->parent();
if (parent) {
delete parent->takeChild(parent->indexOfChild(item));
if (parent == m_rootItems.value(1) && parent->childCount() <= 0) {
useTmpRepositoriesOnly(false);
m_ui->m_useTmpRepositories->setChecked(false);
m_ui->m_useTmpRepositories->setEnabled(false);
}
}
}
}
void ScriptErrorWidget::updateCompileError(const ScriptCompileInfo &info)
{
if(mBaseDir.isEmpty())
return;
QString file = QDir(mBaseDir).relativeFilePath(info.file);
if(file.startsWith("..")) return; // is not a project file
ListWidgetItems oldItems = mItems.take(file);
foreach(QTreeWidgetItem* item, oldItems)
{
QTreeWidgetItem* parent = ui->treeWidget->invisibleRootItem();
int index = parent->indexOfChild(item);
parent->takeChild(index);
delete item;
}
void GlobalSearchSettingsPage::MoveCurrentItem(int d) {
QTreeWidgetItem* item = ui_->sources->currentItem();
if (!item) return;
QTreeWidgetItem* root = ui_->sources->invisibleRootItem();
const int row = root->indexOfChild(item);
const int new_row = qBound(0, row + d, root->childCount());
if (row == new_row) return;
root->removeChild(item);
root->insertChild(new_row, item);
ui_->sources->setCurrentItem(item);
}
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());
}
}
void MainWindow::removeItem()
{
QTreeWidgetItem *currentItem = treeWidget->currentItem();
if (!currentItem)
return;
QTreeWidgetItem *parent = currentItem->parent();
int index;
if (parent) {
index = parent->indexOfChild(treeWidget->currentItem());
delete parent->takeChild(index);
} else {
index = treeWidget->indexOfTopLevelItem(treeWidget->currentItem());
delete treeWidget->takeTopLevelItem(index);
}
}
void QtDcmServersDicomSettingsWidget::removeServer()
{
QTreeWidgetItem * root = treeWidget->invisibleRootItem();
if (!treeWidget->currentItem()) {
return;
}
const int index = root->indexOfChild ( treeWidget->currentItem());
QTreeWidgetItem * item = treeWidget->currentItem();
root->removeChild(item);
delete item;
QtDcmPreferences::instance()->removeServer ( index );
if ( root->childCount() == 0 ) {
echoButton->setEnabled ( false );
removeButton->setEnabled ( false );
}
}
void main_window::on_obj_focus(QTreeWidgetItem *item, int)
{
for (int i = 0; i < m_objects_tree->topLevelItemCount(); ++i)
{
QTreeWidgetItem *p = m_objects_tree->topLevelItem(i);
if (item == p)
{
m_scene_view->set_focus(to_str(p->text(0)), 0);
return;
}
const int idx = p->indexOfChild(item);
if (idx < 0)
continue;
m_scene_view->set_focus(to_str(p->text(0)), idx);
return;
}
}
// delete an item
void UserMenuTree::itemDelete(QTreeWidgetItem *current)
{
int children,index;
QTreeWidgetItem *item, *selectitem;
QTreeWidgetItem *parent = current->parent();
if(!parent) {
children = topLevelItemCount();
index = indexOfTopLevelItem(current);
if ( index < children-1 ) {
selectitem = topLevelItem(index+1);
}
else if ( index > 0 ) {
selectitem = topLevelItem(index-1);
}
else {
selectitem = NULL;
}
item = takeTopLevelItem(index);
}
else {
children = parent->childCount();
index = parent->indexOfChild(current);
if ( index < children-1 ) {
selectitem = parent->child(index+1);
}
else if ( index > 0 ) {
selectitem = parent->child(index-1);
}
else
selectitem = parent; {
}
item = parent->takeChild(index);
}
delete item;
if(selectitem) {
setCurrentItem(selectitem);
}
}
