void TreeWidgetEditor::on_moveItemRightButton_clicked()
{
QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
if (!curItem)
return;
int idx, idxCount;
if (curItem->parent()) {
idx = curItem->parent()->indexOfChild(curItem);
idxCount = curItem->parent()->childCount();
} else {
idx = ui.treeWidget->indexOfTopLevelItem(curItem);
idxCount = ui.treeWidget->topLevelItemCount();
}
if (idx == idxCount - 1)
return;
m_updating = true;
QTreeWidgetItem *takenItem = 0;
if (curItem->parent()) {
QTreeWidgetItem *parentItem = curItem->parent()->child(idx + 1);
takenItem = curItem->parent()->takeChild(idx);
parentItem->insertChild(0, takenItem);
} else {
QTreeWidgetItem *parentItem = ui.treeWidget->topLevelItem(idx + 1);
takenItem = ui.treeWidget->takeTopLevelItem(idx);
parentItem->insertChild(0, takenItem);
}
ui.treeWidget->setCurrentItem(takenItem, ui.listWidget->currentRow());
m_updating = false;
updateEditor();
}
void TreeWidgetEditor::on_moveItemUpButton_clicked()
{
QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
if (!curItem)
return;
int idx;
if (curItem->parent())
idx = curItem->parent()->indexOfChild(curItem);
else
idx = ui.treeWidget->indexOfTopLevelItem(curItem);
if (idx == 0)
return;
m_updating = true;
QTreeWidgetItem *takenItem = 0;
if (curItem->parent()) {
QTreeWidgetItem *parentItem = curItem->parent();
takenItem = parentItem->takeChild(idx);
parentItem->insertChild(idx - 1, takenItem);
} else {
takenItem = ui.treeWidget->takeTopLevelItem(idx);
ui.treeWidget->insertTopLevelItem(idx - 1, takenItem);
}
ui.treeWidget->setCurrentItem(takenItem, ui.listWidget->currentRow());
m_updating = false;
updateEditor();
}
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();
}
// 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);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
QTreeWidgetItem* FilterLibraryTreeWidget::UnwrapTreeItem(QJsonObject object)
{
FilterLibraryTreeWidget::ItemType type = FilterLibraryTreeWidget::ItemType(object["Type"].toInt());
QTreeWidgetItem* item = new QTreeWidgetItem(type);
QString name = object["Name"].toString();
item->setText(0, name);
item->setData(0, Qt::UserRole, name);
if (type == FilterLibraryTreeWidget::Node_Item_Type)
{
item->setIcon(0, QIcon(":/folder_blue.png"));
item->setFlags(item->flags() | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled);
item->setData(2, Qt::UserRole, object["Expanded"].toBool());
for (QJsonObject::iterator iter = object.begin(); iter != object.end(); ++iter)
{
if (iter.value().isObject())
{
QJsonObject childObj = iter.value().toObject();
QTreeWidgetItem* child = FilterLibraryTreeWidget::UnwrapTreeItem(childObj);
item->insertChild(0, child);
}
}
}
else
{
item->setIcon(0, QIcon(":/text.png"));
item->setFlags(item->flags() | Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsDragEnabled);
item->setText(1, object["Path"].toString());
item->setData(1, Qt::UserRole, object["Path"].toString());
}
return item;
}
void TreeWidgetEditor::on_moveItemDownButton_clicked()
{
QTreeWidgetItem *curItem = ui.treeWidget->currentItem();
if (!curItem)
return;
int idx, idxCount;
if (curItem->parent()) {
idx = curItem->parent()->indexOfChild(curItem);
idxCount = curItem->parent()->childCount();
} else {
idx = ui.treeWidget->indexOfTopLevelItem(curItem);
idxCount = ui.treeWidget->topLevelItemCount();
}
if (idx == idxCount - 1)
return;
QTreeWidgetItem *takenItem;
ui.treeWidget->blockSignals(true);
if (curItem->parent()) {
QTreeWidgetItem *parentItem = curItem->parent();
takenItem = parentItem->takeChild(idx);
parentItem->insertChild(idx + 1, takenItem);
} else {
takenItem = ui.treeWidget->takeTopLevelItem(idx);
ui.treeWidget->insertTopLevelItem(idx + 1, takenItem);
}
ui.treeWidget->blockSignals(false);
ui.treeWidget->setCurrentItem(takenItem, ui.treeWidget->currentColumn());
updateEditor();
}
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 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 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 move_to_sorted_position(QTreeWidgetItem* item)
{
assert(item);
if (item->parent())
{
QTreeWidgetItem* parent = item->parent();
parent->removeChild(item);
parent->insertChild(find_sorted_position(parent, item->text(0)), item);
}
else if (item->treeWidget())
{
QTreeWidget* parent = item->treeWidget();
parent->takeTopLevelItem(parent->indexOfTopLevelItem(item));
parent->insertTopLevelItem(find_sorted_position(parent, item->text(0)), item);
}
}
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);
}
void Structure_Toolbar::move_Down(bool)
{
int position = structure_Tree->tree->currentIndex().row();
QTreeWidgetItem* parent = structure_Tree->tree->currentItem()->parent();
// if nested
if(parent)
{
QTreeWidgetItem* taken = parent->takeChild(position+1);
parent->insertChild(position, taken);
} else
{
QTreeWidgetItem* taken = structure_Tree->tree->takeTopLevelItem(position+1);
structure_Tree->tree->insertTopLevelItem(position, taken);
}
refresh_Toolbar();
}
void LibraryTreeWidget::newFolder()
{
QTreeWidgetItem* root = invisibleRootItem();
if (selectedItems().empty() == false)
root = selectedItems().front();
QTreeWidgetItem *item = createFolderItem("New Folder");
root->setExpanded(true);
if (root == invisibleRootItem())
root->addChild(item);
else
root->insertChild(0, item);
editItem(item, 0);
checkModification();
}
void MainWindow::buildBoundaryList() {
QTreeWidgetItem *item = ui.BoundaryTree->topLevelItem(0);
item->child(0)->setText(1,sim.getBoundaryText(0));
item->child(1)->setText(1,sim.getBoundaryText(1));
item->child(2)->setText(1,sim.getBoundaryText(2));
item->child(3)->setText(1,sim.getBoundaryText(3));
item->child(4)->setText(1,sim.getBoundaryText(4));
item->child(5)->setText(1,sim.getBoundaryText(5));
QTreeWidgetItem *new_item;
long int extent_a[2];
long int extent_b[2];
QString type;
QString extents;
double value;
double turbulence;
int n;
for(int i=0; i<6; i++) {
item = ui.BoundaryTree->topLevelItem(1)->child(i);
qDeleteAll(item->takeChildren());
sim.resetSpecialBoundary(i);
while(sim.getNextSpecialBoundary(type, extent_a, extent_b, value, turbulence)) {
new_item = new QTreeWidgetItem(QTreeWidgetItem::Type);
extents = QString::number(extent_a[0]) +
"," + QString::number(extent_a[1]) +
" to " + QString::number(extent_b[0]) +
"," + QString::number(extent_b[1]);
n = item->childCount();
item->insertChild(n, new_item);
new_item->setText(0, QString::number(n+1));
new_item->setText(1, type);
new_item->setText(2, extents);
new_item->setText(3, QString::number(value));
new_item->setText(4, QString::number(turbulence));
}
}
}
void EditContactEntryDialog::on_addButton_clicked()
{
QTreeWidgetItem* item = ui->propertiesTreeWidget->selectedItems().at(0);
QTreeWidgetItem* topLevelItem = item->parent() ? item->parent() : item;
data::ContactProperty::EType type = ui->propertiesTreeWidget->indexOfTopLevelItem(topLevelItem) == 0
? data::ContactProperty::E_TYPE_EMAIL
: data::ContactProperty::E_TYPE_PHONE_NUMBER;
data::ptr<data::ContactProperty> contactProperty(new data::ContactProperty(m_contactEntry, QString(), "<new>", type));
QTreeWidgetItem* newItem = new QTreeWidgetItem();
initPropertiesTreeWidgetItem(newItem, contactProperty);
if (item == topLevelItem)
{
topLevelItem->addChild(newItem);
}
else
{
topLevelItem->insertChild(topLevelItem->indexOfChild(item) + 1, newItem);
}
}
// 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 SettingsDialog::addRepository()
{
int index = 0;
QTreeWidgetItem *parent = m_ui->m_repositoriesView->currentItem();
if (parent && !m_rootItems.contains(parent)) {
parent = parent->parent();
index = parent->indexOfChild(m_ui->m_repositoriesView->currentItem());
}
if (parent) {
Repository repository;
repository.setEnabled(true);
RepositoryItem *item = new RepositoryItem(repository);
parent->insertChild(index, item);
m_ui->m_repositoriesView->editItem(item, 4);
m_ui->m_repositoriesView->scrollToItem(item);
m_ui->m_repositoriesView->setCurrentItem(item);
if (parent == m_rootItems.value(1))
m_ui->m_useTmpRepositories->setEnabled(parent->childCount() > 0);
}
}
QTreeWidgetItem * QgsCustomizationDialog::readWidgetsXmlNode( const QDomNode& theNode )
{
QgsDebugMsg( "Entered" );
QDomElement myElement = theNode.toElement();
QString name = myElement.attribute( "objectName", "" );
QStringList data( name );
data << myElement.attribute( "label", name );
data << myElement.attribute( "description", "" );
QTreeWidgetItem *myItem = new QTreeWidgetItem( data );
// It is nice to have icons for each Qt widget class, is it too heavy?
// There are 47 png files, total 196K in qt/tools/designer/src/components/formeditor/images/
QString iconName = myElement.attribute( "class", "" ).toLower().mid( 1 ) + ".png";
QString iconPath = QgsApplication::iconPath( "/customization/" + iconName );
QgsDebugMsg( "iconPath = " + iconPath );
if ( QFile::exists( iconPath ) )
{
myItem->setIcon( 0, QIcon( iconPath ) );
}
myItem->setFlags( Qt::ItemIsEnabled | Qt::ItemIsUserCheckable | Qt::ItemIsSelectable );
myItem->setCheckState( 0, Qt::Checked );
QDomNode n = theNode.firstChild();
while ( !n.isNull() )
{
QDomElement e = n.toElement();
if ( !e.isNull() )
{
QTreeWidgetItem *wi = readWidgetsXmlNode( n );
myItem->insertChild( 0, wi );
}
n = n.nextSibling();
}
return myItem;
}
/** Moves down an action */
void DlgCustomToolbars::on_moveActionDownButton_clicked()
{
QTreeWidgetItem* item = toolbarTreeWidget->currentItem();
if (item && item->parent() && toolbarTreeWidget->isItemSelected(item)) {
QTreeWidgetItem* parent = item->parent();
int index = parent->indexOfChild(item);
if (index < parent->childCount()-1) {
// 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 moveDownCustomCommand
// which separator it is.
QByteArray data = item->data(0, Qt::UserRole).toByteArray();
if (data == "Separator") {
int countSep = 1;
for (int i=0; i<index; i++) {
QByteArray d = parent->child(i)->data(0, Qt::UserRole).toByteArray();
if (d == "Separator") {
countSep++;
}
}
data += QByteArray::number(countSep);
}
parent->takeChild(index);
parent->insertChild(index+1, item);
toolbarTreeWidget->setCurrentItem(item);
moveDownCustomCommand(parent->text(0), data);
}
}
QVariant data = workbenchBox->itemData(workbenchBox->currentIndex(), Qt::UserRole);
QString workbench = data.toString();
exportCustomToolbars(workbench.toLatin1());
}
void QTreeWidgetItemProto::insertChild(int index, QTreeWidgetItem *child)
{
QTreeWidgetItem *item = qscriptvalue_cast<QTreeWidgetItem*>(thisObject());
if (item)
item->insertChild(index, child);
}
void HierarchyTreeWidget::OnTreeUpdated()
{
EXPANDEDITEMS expandedItems;
EXPANDEDITEMS selectedItems;
//save opened node
TREEITEMS oldItems = GetAllItems();
for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) {
QTreeWidgetItem* item = iter->second;
if (item->isExpanded())
{
QVariant data = item->data(ITEM_ID);
expandedItems.insert(data.toInt());
}
}
//save selected node
for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) {
QTreeWidgetItem* item = iter->second;
if (item->isSelected())
{
QVariant data = item->data(ITEM_ID);
selectedItems.insert(data.toInt());
HierarchyTreeNode* baseNode = HierarchyTreeController::Instance()->GetTree().GetNode(data.toInt());
HierarchyTreeControlNode* selectedControl = dynamic_cast<HierarchyTreeControlNode* >(baseNode);
if(NULL != selectedControl)
{
internalSelectionChanged = true;
}
}
}
//reset tree
ui->treeWidget->clear();
const HierarchyTree& tree = HierarchyTreeController::Instance()->GetTree();
const HierarchyTreeRootNode* rootNode = tree.GetRootNode();
for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = rootNode->GetChildNodes().begin();
iter != rootNode->GetChildNodes().end();
++iter)
{
//add platform node
const HierarchyTreePlatformNode* platformNode = (const HierarchyTreePlatformNode*)(*iter);
QTreeWidgetItem* platformItem = new QTreeWidgetItem();
platformItem->setData(ITEM_ID, platformNode->GetId());
platformItem->setText(0, platformNode->GetName());
platformItem->setIcon(0, QIcon(":/Icons/079i.png"));
ui->treeWidget->insertTopLevelItem(ui->treeWidget->topLevelItemCount(), platformItem);
for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = platformNode->GetChildNodes().begin();
iter != platformNode->GetChildNodes().end();
++iter)
{
const HierarchyTreeScreenNode* screenNode = dynamic_cast<const HierarchyTreeScreenNode*>(*iter);
DVASSERT(screenNode);
QTreeWidgetItem* screenItem = new QTreeWidgetItem();
screenItem->setData(ITEM_ID, screenNode->GetId());
// Check whether this screen was changed.
QString screenItemText = screenNode->GetName();
if (screenNode->GetUnsavedChanges() != 0)
{
screenItemText += " *";
}
screenItem->setText(0, screenItemText);
if (dynamic_cast<const HierarchyTreeAggregatorNode*>(screenNode))
screenItem->setIcon(0, QIcon(":/Icons/170.png"));
else
screenItem->setIcon(0, QIcon(":/Icons/068i.png"));
platformItem->insertChild(platformItem->childCount(), screenItem);
AddControlItem(screenItem, selectedItems, expandedItems, screenNode->GetChildNodes());
if (expandedItems.find(screenNode->GetId()) != expandedItems.end())
screenItem->setExpanded(true);
if (selectedItems.find(screenNode->GetId()) != selectedItems.end())
{
screenItem->setSelected(true);
}
}
if (expandedItems.find(platformNode->GetId()) != expandedItems.end())
platformItem->setExpanded(true);
if (selectedItems.find(platformNode->GetId()) != selectedItems.end())
{
platformItem->setSelected(true);
}
}
internalSelectionChanged = false;
}
void GraphModeler::moveItem(QTreeWidgetItem *item, QTreeWidgetItem *above)
{
if (item)
{
if (above)
{
//item->moveItem(above);
item->parent()->removeChild(item);
QTreeWidgetItem *parent = above->parent();
parent->insertChild(parent->indexOfChild(above), item );
//Move the object in the Sofa Node.
if (above && getObject(item))
{
Node *n=getNode(item);
Node::ObjectIterator A=n->object.end();
Node::ObjectIterator B=n->object.end();
BaseObject* objectA=getObject(above);
BaseObject* objectB=getObject(item);
bool inversion=false;
//Find the two objects in the Sequence of the Node
for (Node::ObjectIterator it=n->object.begin(); it!=n->object.end(); ++it)
{
if( *it == objectA)
{
A=it;
if (B!=n->object.end()) inversion=true;
}
else if ( *it == objectB) B=it;
}
//One has not been found: should not happen
if (A==n->object.end() || B==n->object.end()) return;
//Invert the elements
Node::ObjectIterator it;
if (inversion) n->object.swap(A,B);
else
{
for (it=B; it!=A+1; --it) n->object.swap(it,it-1);
}
}
}
else
{
//Object
if (getObject(item))
{
QTreeWidgetItem *nodeQt = graphListener->items[getNode(item)];
QTreeWidgetItem *firstComp=nodeQt->child(0);
if (firstComp != item) initItem(item, firstComp);
}
//Node
else
{
QTreeWidgetItem *nodeQt = graphListener->items[getNode(item->parent())];
QTreeWidgetItem *firstComp=nodeQt->child(0);
if (firstComp != item) initItem(item, firstComp);
}
}
}
}
void LibraryTreeWidget::addNewFile()
{
QDir dir = QFileInfo(projectFileName_).dir();
AddNewFileDialog addNewFile(dir.path(), this);
while (1)
{
if (addNewFile.exec() == QDialog::Accepted)
{
QDir newdir = dir;
if (newdir.cd(addNewFile.location()) == false)
{
QMessageBox::critical(this, tr("Gideros"), tr("Directory %1 does not exist.").arg(addNewFile.location()));
continue;
}
QString filename = newdir.absoluteFilePath(addNewFile.fileName());
QFile file(filename);
// check if it is exists or not
if (file.exists() == true)
{
QMessageBox::critical(this, tr("Gideros"), tr("A file with the name %1 already exists on disk.").arg(filename));
continue;
}
// TODO: check if this file is already on the project. bunu bi dusun. library'deki ismimi yoksa diskteki ismimi onemlidir
//QString relfilename = dir.relativeFilePath(filename);
//if (isFileAlreadyImported(relfilename))
//{
// 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));
// continue;
//}
// try to create an empty file
if (!file.open(QIODevice::WriteOnly | QIODevice::Text))
{
QMessageBox::critical(this, tr("Gideros"), tr("The file %1 could not be created.").arg(filename));
continue;
}
file.close();
// add file to the project
QTreeWidgetItem* root = invisibleRootItem();
if (selectedItems().empty() == false)
root = selectedItems().front();
QTreeWidgetItem *item = createFileItem(dir.relativeFilePath(filename));
if (root == invisibleRootItem())
root->addChild(item);
else
root->insertChild(0, item);
root->setExpanded(true);
break;
}
else
{
break;
}
}
}
void HierarchyTreeWidget::OnTreeUpdated(bool needRestoreSelection)
{
EXPANDEDITEMS expandedItems;
EXPANDEDITEMS selectedItems;
//save opened node
TREEITEMS oldItems = GetAllItems();
for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) {
QTreeWidgetItem* item = iter->second;
if (item->isExpanded())
{
QVariant data = item->data(ITEM_ID);
expandedItems.insert(data.toInt());
}
}
//save selected node
for (TREEITEMS::iterator iter = oldItems.begin(); iter != oldItems.end(); ++iter) {
QTreeWidgetItem* item = iter->second;
if (item->isSelected())
{
QVariant data = item->data(ITEM_ID);
selectedItems.insert(data.toInt());
HierarchyTreeNode* baseNode = HierarchyTreeController::Instance()->GetTree().GetNode(data.toInt());
HierarchyTreeControlNode* selectedControl = dynamic_cast<HierarchyTreeControlNode* >(baseNode);
if(NULL != selectedControl)
{
internalSelectionChanged = true;
}
}
}
//reset tree
ui->treeWidget->clear();
const HierarchyTree& tree = HierarchyTreeController::Instance()->GetTree();
const HierarchyTreeRootNode* rootNode = tree.GetRootNode();
for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = rootNode->GetChildNodes().begin();
iter != rootNode->GetChildNodes().end();
++iter)
{
//add platform node
const HierarchyTreePlatformNode* platformNode = (const HierarchyTreePlatformNode*)(*iter);
QTreeWidgetItem* platformItem = new QTreeWidgetItem();
platformItem->setData(ITEM_ID, platformNode->GetId());
QString platformName = platformNode->GetName();
if (platformNode->IsNeedSave())
{
platformName += " *";
}
platformItem->setText(0, platformName);
platformItem->setIcon(0, QIcon(IconHelper::GetPlatformIconPath()));
ui->treeWidget->insertTopLevelItem(ui->treeWidget->topLevelItemCount(), platformItem);
for (HierarchyTreeNode::HIERARCHYTREENODESLIST::const_iterator iter = platformNode->GetChildNodes().begin();
iter != platformNode->GetChildNodes().end();
++iter)
{
const HierarchyTreeScreenNode* screenNode = dynamic_cast<const HierarchyTreeScreenNode*>(*iter);
DVASSERT(screenNode);
QTreeWidgetItem* screenItem = new QTreeWidgetItem();
screenItem->setData(ITEM_ID, screenNode->GetId());
// Check whether this screen was changed.
QString screenItemText = screenNode->GetName();
if (screenNode->IsNeedSave())
{
screenItemText += " *";
}
screenItem->setText(0, screenItemText);
if (dynamic_cast<const HierarchyTreeAggregatorNode*>(screenNode))
screenItem->setIcon(0, QIcon(IconHelper::GetAggregatorIconPath()));
else
screenItem->setIcon(0, QIcon(IconHelper::GetScreenIconPath()));
platformItem->insertChild(platformItem->childCount(), screenItem);
AddControlItem(screenItem, screenNode->GetChildNodes());
}
}
// Restore the selected items only after the tree is fully built.
int itemsCount = ui->treeWidget->topLevelItemCount();
for (int i = 0; i < itemsCount; i ++)
{
QTreeWidgetItem* rootItem = ui->treeWidget->topLevelItem(i);
RestoreTreeItemExpandedStateRecursive(rootItem, expandedItems);
if (needRestoreSelection)
{
RestoreTreeItemSelectedStateRecursive(rootItem, selectedItems);
}
}
internalSelectionChanged = false;
}
void lcTimelineWidget::Update(bool Clear, bool UpdateItems)
{
if (mIgnoreUpdates)
return;
lcModel* Model = lcGetActiveModel();
if (!Model)
{
mItems.clear();
clear();
return;
}
bool Blocked = blockSignals(true);
if (Clear)
{
mItems.clear();
clear();
}
lcStep LastStep = lcMax(Model->GetLastStep(), Model->GetCurrentStep());
for (int TopLevelItemIdx = LastStep; TopLevelItemIdx < topLevelItemCount(); )
{
QTreeWidgetItem* StepItem = topLevelItem(TopLevelItemIdx);
while (StepItem->childCount())
{
QTreeWidgetItem* PieceItem = StepItem->child(0);
lcPiece* Piece = (lcPiece*)PieceItem->data(0, Qt::UserRole).value<uintptr_t>();
mItems.remove(Piece);
delete PieceItem;
}
delete StepItem;
}
for (unsigned int TopLevelItemIdx = topLevelItemCount(); TopLevelItemIdx < LastStep; TopLevelItemIdx++)
{
QTreeWidgetItem* StepItem = new QTreeWidgetItem(this, QStringList(tr("Step %1").arg(TopLevelItemIdx + 1)));
StepItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsDropEnabled);
addTopLevelItem(StepItem);
StepItem->setExpanded(true);
}
const lcArray<lcPiece*>& Pieces = Model->GetPieces();
QTreeWidgetItem* StepItem = NULL;
int PieceItemIndex = 0;
lcStep Step = 0;
for (int PieceIdx = 0; PieceIdx != Pieces.GetSize(); PieceIdx++)
{
lcPiece* Piece = Pieces[PieceIdx];
while (Step != Piece->GetStepShow())
{
if (StepItem)
{
while (PieceItemIndex < StepItem->childCount())
{
QTreeWidgetItem* PieceItem = StepItem->child(PieceItemIndex);
lcPiece* RemovePiece = (lcPiece*)PieceItem->data(0, Qt::UserRole).value<uintptr_t>();
if (Pieces.FindIndex(RemovePiece) == -1)
{
mItems.remove(RemovePiece);
delete PieceItem;
}
else
{
PieceItem->parent()->removeChild(PieceItem);
topLevelItem(RemovePiece->GetStepShow() - 1)->addChild(PieceItem);
}
}
}
Step++;
StepItem = topLevelItem(Step - 1);
PieceItemIndex = 0;
}
QTreeWidgetItem* PieceItem = mItems.value(Piece);
bool UpdateItem = UpdateItems;
if (!PieceItem)
{
PieceItem = new QTreeWidgetItem();
PieceItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsDragEnabled);
PieceItem->setData(0, Qt::UserRole, qVariantFromValue<uintptr_t>((uintptr_t)Piece));
StepItem->insertChild(PieceItemIndex, PieceItem);
mItems[Piece] = PieceItem;
UpdateItem = true;
}
else
{
if (PieceItemIndex >= StepItem->childCount() || PieceItem != StepItem->child(PieceItemIndex))
{
QTreeWidgetItem* PieceParent = PieceItem->parent();
if (PieceParent)
PieceParent->removeChild(PieceItem);
StepItem->insertChild(PieceItemIndex, PieceItem);
}
}
if (UpdateItem)
{
PieceItem->setText(0, Piece->mPieceInfo->m_strDescription);
int ColorIndex = Piece->mColorIndex;
if (!mIcons.contains(ColorIndex))
{
int Size = rowHeight(indexFromItem(PieceItem));
QImage Image(Size, Size, QImage::Format_ARGB32);
Image.fill(QColor::fromRgbF(1.0, 1.0, 1.0, 0.0));
float* Color = gColorList[ColorIndex].Value;
QPainter Painter(&Image);
Painter.setPen(Qt::NoPen);
Painter.setBrush(QColor::fromRgbF(Color[0], Color[1], Color[2]));
Painter.drawEllipse(QPoint(Size / 2, Size / 2), Size / 2, Size / 2);
mIcons[ColorIndex] = QIcon(QPixmap::fromImage(Image));
}
PieceItem->setIcon(0, mIcons[ColorIndex]);
QColor Color = palette().text().color();
if (Piece->IsHidden())
Color.setAlpha(128);
PieceItem->setTextColor(0, Color);
}
PieceItem->setSelected(Piece->IsSelected());
PieceItemIndex++;
}
if (Step == 0)
{
Step = 1;
StepItem = topLevelItem(0);
}
while (Step <= LastStep)
{
while (PieceItemIndex < StepItem->childCount())
{
QTreeWidgetItem* PieceItem = StepItem->child(PieceItemIndex);
lcPiece* RemovePiece = (lcPiece*)PieceItem->data(0, Qt::UserRole).value<uintptr_t>();
mItems.remove(RemovePiece);
delete PieceItem;
}
Step++;
StepItem = topLevelItem(Step - 1);
PieceItemIndex = 0;
}
blockSignals(Blocked);
}
