void MessageTreeWidget::recoverMessageItem()
{
QString strName= currentClickItem->text(0);
QString strContent = currentClickItem->text(1);
QString strNumber = strName;
QString strTerm = "错误";
if(mapName2Number.contains(strName))
{
strNumber = mapName2Number[strName];
}
if(mapblackNumberTerm.contains(strName))
{
strTerm = mapblackNumberTerm[strName];
}
// QMessageBox *message=new QMessageBox(QMessageBox::NoIcon, strNumber, strTerm);
// message->show();
QString strSmsSum = "信息";
addSmsElemt(strMessagePathOpen,strNumber,strContent,strTerm,strSmsSum);
QTreeWidgetItem *item = currentClickItem;
QTreeWidgetItem *parent = item->parent();
parent->removeChild(currentClickItem);
currentClickItem = NULL;
writeXml(strMessagePathSave,this);
emit updateTreeAllItem();
}
void KoRdfSemanticTreePrivate::clear(QTreeWidgetItem *parent)
{
while (parent->childCount()) {
QTreeWidgetItem* c = parent->child(0);
m_peopleItem->removeChild(c);
delete c;
}
}
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 CantactTreeWidget::deleteCantact()
{
int ret = QMessageBox::warning(NULL, "warning", "确定要删除该联系人吗？", QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
if(ret == QMessageBox::Yes)
{
QTreeWidgetItem *item = currentWidgetItem;
QTreeWidgetItem *parent = item->parent();
parent->removeChild(currentWidgetItem);
currentWidgetItem = NULL;
}
}
void CantactTreeWidget::recoverCantact()//
{
if(currentWidgetItem != NULL)
{
QTreeWidgetItem *item = new QTreeWidgetItem(cantactTreeItem);
item->setText(0,currentWidgetItem->text(0));
item->setText(1,currentWidgetItem->text(1));
QTreeWidgetItem *parent = currentWidgetItem->parent();
parent->removeChild(currentWidgetItem);
currentWidgetItem = NULL;
}
}
void CantactTreeWidget::moveToWhitelist()
{
if(currentWidgetItem != NULL)
{
QTreeWidgetItem *item = new QTreeWidgetItem(whiteTreeItem);
item->setText(0,currentWidgetItem->text(0));
item->setText(1,currentWidgetItem->text(1));
QTreeWidgetItem *parent = currentWidgetItem->parent();
parent->removeChild(currentWidgetItem);
currentWidgetItem = NULL;
}
}
void TreeNotebookItem::removePageItem(QString sectionName, NotebookPage* page)
{
Q_UNUSED(sectionName);
Q_ASSERT(page);
QTreeWidgetItem* sectionTree = 0;
TreeNotebookPageItem* pageNode = 0;
this->getPathToPage(*page, sectionTree, pageNode);
Q_ASSERT(sectionTree);
Q_ASSERT(pageNode);
sectionTree->removeChild(pageNode);
}
/**
* populate title list of updated and
* not updated fields
*/
void EksigatorWindow::populateList()
{
//flush tree
//@todo there's a bug here, flushing tree is not working well
QTreeWidgetItem *treeUpdated = ui->treeWidget->topLevelItem(0);
QTreeWidgetItemIterator it(treeUpdated);
while (*it) {
treeUpdated->removeChild(it.operator *());
++it;
}
QTreeWidgetItem *treeNotUpdated = ui->treeWidget->topLevelItem(1);
QTreeWidgetItemIterator itNotUpdated(treeNotUpdated);
while (*itNotUpdated) {
treeNotUpdated->removeChild(itNotUpdated.operator *());
++itNotUpdated;
}
//qWarning() << updatedTitles.join(" | ");
//@todo and there should be another way for adding a QStringList
for (int i = 0; i < updatedTitles.size(); ++i) {
QTreeWidgetItem *title = new QTreeWidgetItem();
title->setText( 0, updatedTitles.at(i));
treeUpdated->addChild(title);
}
for (int i = 0; i < notUpdatedTitles.size(); ++i) {
QTreeWidgetItem *title = new QTreeWidgetItem();
title->setText( 0, notUpdatedTitles.at(i));
treeNotUpdated->addChild(title);
}
}
void VSCDeviceTree::VSCZbIpcDeleteClick()
{
QTreeWidgetItem* child = currentItem();
QTreeWidgetItem* parent = currentItem()->parent();
VSCZbTreeItemIPC *pVSCZbIpc = dynamic_cast<VSCZbTreeItemIPC * >(child);
u32 nId = pVSCZbIpc->GetDeviceId();
pVSCZbIpc->DeleteTreeItemIPC();
if(parent)
{
parent->removeChild(child);
}
emit VSCZbIpcDeleteClicked(nId);
return;
}
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 AssetsWindow::RemoveAsset(AssetPtr asset)
{
QTreeWidgetItemIterator it(treeWidget);
while(*it)
{
AssetItem *item = dynamic_cast<AssetItem *>(*it);
if (item && item->Asset() && item->Asset() == asset)
{
QTreeWidgetItem *parent = item->parent();
parent->removeChild(item);
SAFE_DELETE(item);
}
++it;
}
}
void ItemTreeViewImpl::onSubTreeRemoved(Item* item, bool isMoving)
{
isProceccingSlotForRootItemSignals++;
ItvItem* itvItem = getItvItem(item);
if(itvItem){
QTreeWidgetItem* parentTwItem = itvItem->parent();
if(parentTwItem){
parentTwItem->removeChild(itvItem);
} else {
takeTopLevelItem(indexOfTopLevelItem(itvItem));
}
delete itvItem;
}
isProceccingSlotForRootItemSignals--;
}
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 VSCDeviceList::NotifyDelVIPC(int nId)
{
QTreeWidgetItem *qtreewidgetitem = ui.treeWidget->topLevelItem(VSC_DEVICE_INDEX_V_IPC);
int cnt = qtreewidgetitem->childCount();
//VDC_DEBUG( "%s cnt %d\n",__FUNCTION__, cnt);
for (int i = 0; i < cnt; i ++)
{
QTreeWidgetItem * pChild = qtreewidgetitem->child(i);
VSCVIPC *pVIPC = dynamic_cast<VSCVIPC*>(pChild);
if (pVIPC && pVIPC->GetDeviceId() == nId)
{
qtreewidgetitem->removeChild(pChild);
}
}
return;
}
void tst_ModelTest::treeWidgetModel()
{
QTreeWidget widget;
ModelTest t1(widget.model());
QTreeWidgetItem *root = new QTreeWidgetItem(&widget, QStringList("root"));
for (int i = 0; i < 20; ++i) {
new QTreeWidgetItem(root, QStringList(QString::number(i)));
}
QTreeWidgetItem *remove = root->child(2);
root->removeChild(remove);
QTreeWidgetItem *parent = new QTreeWidgetItem(&widget, QStringList("parent"));
new QTreeWidgetItem(parent, QStringList("child"));
widget.setItemHidden(parent, true);
widget.sortByColumn(0);
}
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 StationDialog::on_delButton_clicked()
{
QList<QTreeWidgetItem *> list = m_ui->stationTree->selectedItems();
QTreeWidgetItem *item;
int i;
for(i=0; i<list.count(); i++) {
item = (QTreeWidgetItem *)list.at(i);
while(!item->childCount())
item = m_ui->stationTree->itemAbove(item);
while(item->childCount())
item->removeChild(item->child(0));
delete item;
}
if(!m_ui->stationTree->topLevelItemCount())
m_ui->delButton->setEnabled(false);
}
void TreeNotebookItem::updatePageItem(NotebookPage* page, QString sectionName, int index)
{
Q_ASSERT(page);
QTreeWidgetItem* sectionTree = 0;
TreeNotebookPageItem* pageNode = 0;
this->getPathToPage(*page, sectionTree, pageNode);
Q_ASSERT(sectionTree);
Q_ASSERT(pageNode);
QTreeWidgetItem& newSectionTree = this->findOrCreateSectionItem(sectionName);
sectionTree->removeChild(pageNode);
newSectionTree.insertChild(index, pageNode);
// update tree path index
this->sectionTrees[page].first = &newSectionTree;
// TODO: Prevent change of selection when moving nodes
}
void CastTreeViewer::deleteFolder() {
QTreeWidgetItem *item = currentItem();
if (!item || !item->parent()) return;
QString itemName = item->data(0, Qt::DisplayRole).toString();
if (itemName == AudioFolderName) return;
int ret = DVGui::MsgBox(tr("Delete folder ") + item->text(0) + "?", tr("Yes"),
tr("No"), 1);
if (ret == 2 || ret == 0) return;
QTreeWidgetItem *parentItem = item->parent();
TFilePath childPath(item->data(1, Qt::DisplayRole).toString().toStdWString());
TLevelSet *levelSet =
TApp::instance()->getCurrentScene()->getScene()->getLevelSet();
levelSet->removeFolder(childPath);
TApp::instance()->getCurrentScene()->setDirtyFlag(true);
parentItem->removeChild(item);
setCurrentItem(parentItem);
}
//---------------------------------------------------------------------------
void StationDialog::on_addButton_clicked()
{
QTreeWidgetItem *child;
QTreeWidgetItem *item;
QString str;
double v;
if(!checkInput())
return;
QList<QTreeWidgetItem *> list = m_ui->stationTree->findItems(m_ui->nameEdit->text(), Qt::MatchExactly);
if(list.count()) {
item = (QTreeWidgetItem *)list.at(0);
while(item->childCount())
item->removeChild(item->child(0));
}
else {
item = new QTreeWidgetItem(QTreeWidgetItem::DontShowIndicatorWhenChildless);
item->setText(0, m_ui->nameEdit->text());
}
v = atof(m_ui->lonEdit->text().toStdString().c_str());
str.sprintf("Longitude: %g %s", fabs(v), v < 0 ? "West":"East");
child = new QTreeWidgetItem(QTreeWidgetItem::DontShowIndicatorWhenChildless);
child->setText(0, str);
item->addChild(child);
v = atof(m_ui->latEdit->text().toStdString().c_str());
str.sprintf("Latitude: %g %s", fabs(v), v < 0 ? "South":"North");
child = new QTreeWidgetItem(QTreeWidgetItem::DontShowIndicatorWhenChildless);
child->setText(0, str);
item->addChild(child);
v = atof(m_ui->altEdit->text().toStdString().c_str());
str.sprintf("Altitude: %g meter", v);
child = new QTreeWidgetItem(QTreeWidgetItem::DontShowIndicatorWhenChildless);
child->setText(0, str);
item->addChild(child);
m_ui->stationTree->addTopLevelItem(item);
item->setExpanded(true);
}
bool BookmarkGui::removeEvaluation()
{
Bookmark bk ;
QueryResult favorite ;
QTreeWidgetItem *item ;
bk.getFavoriteFullData( favorite , this->current_favorite );
QList<QTreeWidgetItem *> list =
ui->treeEvaluations->findItems ( favorite.getField( "Id" , favorite.begin() ) , Qt::MatchExactly|Qt::MatchRecursive , 1 ) ;
if ( list.size() > 1 || list.isEmpty() ) return false ;
item = list.first() ;
if ( item->type() != BookmarkGui::item_article ) return false ;
QTreeWidgetItem *parent = item->parent() ;
parent->removeChild( item ); ;
return true ;
}
void ObjectInspectorTable::dropEvent(QDropEvent *event) {
if ( event->source() == this ) {
QTreeWidgetItem *target = itemAt(event->pos());
if ( target ) {
if ( m_objectMap[target] ) { // on est pas sur un layout !
target = target->parent();
}
foreach (QTreeWidgetItem *it, selectedItems()) {
if ( m_objectMap[it] ) { // on est pas sur un layout !
// re retrouve le layout source
QTreeWidgetItem *source = it;
if ( m_objectMap[source] ) { // on est pas sur un layout !
source = source->parent();
}
// source != target ?
if (source != target) {
source->removeChild(it);
target->addChild(it);
m_objectMap[it]->setZValue(-indexOfTopLevelItem(target) - 1);
Log::d("ObjectInspectorTable") << "dropEvent, zIndex = " << -indexOfTopLevelItem(target) - 1;
m_objectMap[it]->setVisible( target->checkState(0) == Qt::Checked );
target->setExpanded(true);
} else {
Log::w("ObjectInspectorTable") << "drop event, source == target";
}
}
}
Log::d("ObjectInspectorTable") << "drop event, target = " << target->data(0, Qt::DisplayRole).toString();
}
event->accept();
} else { // mauvais format mine
void QMwStructuresWidget::ContextMenuWrapInEntitySetTriggered()
{
MwBaseResource *contextMenuResource = this->GetMwResourceFromItem(this->contextMenuItem);
QTreeWidgetItem *contextItemParent = this->GetItemParent(this->contextMenuItem);
MwEntitySet *contextParentSet = (MwEntitySet*)this->GetMwResourceFromItem(contextItemParent);
int contextItemIndex = contextItemParent->indexOfChild(this->contextMenuItem);
// Create new entity set and put the resoruce inside
MwEntitySet *newSet = (MwEntitySet*)this->editor->GetMeshwork()->AddResource(*new MwEntitySet());
newSet->name = this->editor->GetMeshwork()->AcquireResourceName(contextMenuResource->name, MwResourceType_EntitySet);
newSet->references.Add(contextMenuResource);
// Remove the resource and put the new entity set in its place
contextParentSet->references.RemoveAt(contextItemIndex);
contextParentSet->references.Insert(contextItemIndex, newSet);
// Create the new tree widget item
QTreeWidgetItem *item = new QTreeWidgetItem(contextItemParent);
this->BuildStructureTreeNode(newSet, item, true);
// Remove the old tree widget item and put the new one in its place
contextItemParent->removeChild(this->contextMenuItem);
this->InsertItem(contextItemParent, item, contextItemIndex);
}
void QTreeWidgetItemProto::removeChild(QTreeWidgetItem *child)
{
QTreeWidgetItem *item = qscriptvalue_cast<QTreeWidgetItem*>(thisObject());
if (item)
item->removeChild(child);
}
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);
}
/**
* @brief RsCollectionDialog::remove: Remove selected Items in RSCollection
*/
void RsCollectionDialog::remove()
{
bool removeOnlyFile=false;
QString listDir;
// First, check if selection contains directories
for (int curs = 0; curs < ui._fileEntriesTW->selectedItems().count(); ++curs)
{// Have to call ui._fileEntriesTW->selectedItems().count() each time as selected could change
QTreeWidgetItem *item = NULL;
item= ui._fileEntriesTW->selectedItems().at(curs);
//Uncheck child directory item if parent is checked
if (item != getRootItem()){
if (item->data(COLUMN_HASH, ROLE_TYPE).toUInt() == DIR_TYPE_DIR) {
QString path = item->data(COLUMN_HASH, ROLE_PATH).toString();
if (listDir.contains(path) && !path.isEmpty()) {
item->setSelected(false);
} else {
listDir += item->data(COLUMN_HASH, ROLE_NAME).toString() +"<br>";
}//if (listDir.contains(item->data(COLUMN_HASH, ROLE_PATH).toString()))
}//if (item->data(COLUMN_HASH, ROLE_TYPE).toUInt() == DIR_TYPE_DIR)
}//if (item != getRootItem())
}//for (int curs = 0; curs < count; ++curs)
//If directories, ask to remove them or not
if (!listDir.isEmpty()){
QMessageBox* msgBox = new QMessageBox(QMessageBox::Information, "", "");
msgBox->setText("Warning, selection contains directories.");
//msgBox->setInformativeText(); If text too long, no scroll, so I add an text edit
QGridLayout* layout = qobject_cast<QGridLayout*>(msgBox->layout());
if (layout) {
QTextEdit* edit = new QTextEdit(tr("Do you want to remove them and all their children, too? <br>") + listDir);
edit->setReadOnly(true);
layout->addWidget(edit,0 ,1);
}
msgBox->setStandardButtons(QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
msgBox->setDefaultButton(QMessageBox::Yes);
int ret = msgBox->exec();
switch (ret) {
case QMessageBox::Yes:
break;
case QMessageBox::No:
removeOnlyFile = true;
break;
case QMessageBox::Cancel: {
delete msgBox;
return;
}//case QMessageBox::Cancel:
break;
default:
// should never be reached
break;
}//switch (ret)
delete msgBox;
}//if (!listDir.isEmpty())
//Remove wanted items
for (int curs = 0; curs < ui._fileEntriesTW->selectedItems().count(); ++curs)
{// Have to call ui._fileEntriesTW->selectedItems().count() each time as selected change
QTreeWidgetItem *item = NULL;
item= ui._fileEntriesTW->selectedItems().at(curs);
if (item != getRootItem()){
if ((item->data(COLUMN_HASH, ROLE_TYPE).toUInt() != DIR_TYPE_DIR) || !removeOnlyFile) {
QTreeWidgetItem *parent = item->parent();
parent->removeChild(item);
curs = 0;//Cause we don't know how many child of this item was selected (and don't want iterate them ;) )
}
}//if (item != getRootItem())*
}//for (int curs = 0; curs < count; ++curs)
}
void QMwStructuresWidget::dropEvent(QDropEvent *event)
{
unsigned int resource;
if (!MwString(event->mimeData()->data("application/mwresource").data()).ToUInt(resource))
{
event->ignore();
return;
}
MwBaseResource *droppedResource = (MwBaseResource*)resource;
QTreeWidgetItem *destItemParent;
MwEntitySet *destParentSet;
int destIndex;
QTreeWidgetItem *destItem = this->itemAt(event->pos());
if (destItem != 0)
{
destItemParent = this->GetItemParent(destItem);
destParentSet = (MwEntitySet*)this->GetMwResourceFromItem(destItemParent);
destIndex = destItemParent->indexOfChild(destItem);
}
else
{
destItemParent = this->invisibleRootItem();
destParentSet = this->editor->GetMeshwork()->root;
destIndex = this->editor->GetMeshwork()->root->references.count;
}
switch (this->dragMode)
{
case QMwStructuresWidget::DragMode_None:
{
destParentSet->references.Insert(destIndex, droppedResource);
QTreeWidgetItem *item = new QTreeWidgetItem(destItemParent);
QMwStructuresWidget::SetMwResourceToItem(item, droppedResource);
this->InsertItem(destItemParent, destItem, destIndex);
event->acceptProposedAction();
break;
}
// Dragging has started from this widget, so the dropped resource has to be moved. In order to do that, first we need to remove it from its old location
case QMwStructuresWidget::DragMode_Resource:
{
unsigned int sourceItemAddress;
if (!MwString(event->mimeData()->data("application/twitem").data()).ToUInt(sourceItemAddress))
break;
QTreeWidgetItem *sourceItem = (QTreeWidgetItem*)sourceItemAddress;
if (sourceItem == destItem)
break;
QTreeWidgetItem *sourceItemParent = this->GetItemParent(sourceItem);
MwEntitySet *sourceParentSet = (MwEntitySet*)this->GetMwResourceFromItem(sourceItemParent);
int sourceIndex = sourceItemParent->indexOfChild(sourceItem);
if ((sourceItemParent == destItemParent) && (sourceIndex < destIndex))
destIndex--;
sourceParentSet->references.RemoveAt(sourceIndex);
sourceItemParent->removeChild(sourceItem);
destParentSet->references.Insert(destIndex, droppedResource);
this->InsertItem(destItemParent, sourceItem, destIndex);
event->acceptProposedAction();
break;
}
}
}
bool CQRDFTreeView::enterProtected()
{
clear();
CCopasiObject *pObject = dynamic_cast< CCopasiObject * >(CCopasiRootContainer::getKeyFactory()->get(mKey));
if (pObject != NULL)
{
CModelEntity * pEntity = NULL;
CEvent * pEvent = NULL;
CReaction * pReaction = NULL;
CFunction * pFunction = NULL;
const std::string * pMiriamAnnotation = NULL;
if ((pEntity = dynamic_cast< CModelEntity * >(pObject)) != NULL)
pMiriamAnnotation = &pEntity->getMiriamAnnotation();
else if ((pEvent = dynamic_cast< CEvent * >(pObject)) != NULL)
pMiriamAnnotation = &pEvent->getMiriamAnnotation();
else if ((pReaction = dynamic_cast< CReaction * >(pObject)) != NULL)
pMiriamAnnotation = &pReaction->getMiriamAnnotation();
else if ((pFunction = dynamic_cast< CFunction * >(pObject)) != NULL)
pMiriamAnnotation = &pFunction->getMiriamAnnotation();
if (pMiriamAnnotation && *pMiriamAnnotation != "")
mpGraph = CRDFParser::graphFromXml(*pMiriamAnnotation);
}
CCopasiMessage::clearDeque();
if (CCopasiMessage::size() != 0)
{
QString Message = FROM_UTF8(CCopasiMessage::getAllMessageText());
CQMessageBox::warning(this, QString("RDF Warning"), Message,
QMessageBox::Ok, QMessageBox::Ok);
}
if (mpGraph == NULL)
mpGraph = new CRDFGraph;
// We make sure that we always have an about node.
mpGraph->createAboutNode(mKey);
// We iterate of all triplets
std::set< CRDFTriplet >::const_iterator it = mpGraph->getTriplets().begin();
std::set< CRDFTriplet >::const_iterator end = mpGraph->getTriplets().end();
for (; it != end; ++it)
{
CQRDFTreeViewItem * pSubjectItem = find(it->pSubject);
if (pSubjectItem == NULL)
{
pSubjectItem = new CQRDFTreeViewItem(mpTreeWidget, NULL);
insert(it->pSubject, pSubjectItem);
// Display the subject information
const CRDFSubject & Subject = it->pSubject->getSubject();
switch (Subject.getType())
{
case CRDFSubject::RESOURCE:
pSubjectItem->setText(COL_SUBJECT, FROM_UTF8(Subject.getResource()));
break;
case CRDFSubject::BLANK_NODE:
pSubjectItem->setText(COL_SUBJECT, FROM_UTF8(Subject.getBlankNodeID()));
break;
}
}
CQRDFTreeViewItem * pObjectItem = NULL;
if (it->Predicate.getURI() == "http://www.w3.org/1999/02/22-rdf-syntax-ns#subject")
{
pObjectItem = new CQRDFTreeViewItem(pSubjectItem, NULL);
insert(it->pObject, pObjectItem);
}
else
pObjectItem = find(it->pObject);
if (pObjectItem == NULL)
{
pObjectItem = new CQRDFTreeViewItem(pSubjectItem, NULL);
insert(it->pObject, pObjectItem);
}
else
{
QTreeWidgetItem * pParent = pObjectItem->parent();
if (pParent == NULL)
{
mpTreeWidget->invisibleRootItem()->removeChild(pObjectItem);
pSubjectItem->addChild(pObjectItem);
}
else
{
pParent->removeChild(pObjectItem);
pSubjectItem->addChild(pObjectItem);
}
}
pObjectItem->setTriplet(*it);
}
mpTreeWidget->setFocus();
return true;
}
void TupItemManager::dropEvent(QDropEvent *event)
{
bool eventAccept = false;
if (event->mimeData()->hasFormat("application/x-dnditemdata")) {
QByteArray itemData = event->mimeData()->data("application/x-dnditemdata");
QDataStream dataStream(&itemData, QIODevice::ReadOnly);
QPixmap pixmap;
QString label;
QString extension;
QString key;
dataStream >> pixmap >> label >> extension >> key;
QTreeWidgetItem *item;
QTreeWidgetItem *parent = itemAt(event->pos().x(), event->pos().y());
if (parent) {
// If both Target and Origin are directories
if (parentNode.length() > 0) {
if ((parent->text(2).length() == 0) && (extension.length() == 0))
return;
}
// Ensure Target is a directory
if (parent->text(2).length() > 0)
return;
// Target is going to the same parent
int childrenTotal = parent->childCount();
for (int i=0;i < childrenTotal; i++) {
QTreeWidgetItem *child = parent->child(i);
QString name = child->text(1);
if (name.compare(label) == 0 && child->text(2).compare(extension) == 0)
return;
}
// Make sure node and target are not the same
if (extension.length() > 0) {
if (parentNode.length() > 0) {
QList<QTreeWidgetItem *> nodes = findItems(parentNode, Qt::MatchExactly, 1);
for (int i = 0; i < nodes.size(); ++i) {
QTreeWidgetItem *node = nodes.at(i);
if (node->text(1).compare(parentNode) == 0) {
int childrenTotal = node->childCount();
for (int i=0;i < childrenTotal; i++) {
QTreeWidgetItem *child = node->child(i);
if (child->text(1).compare(label) == 0 && child->text(2).compare(extension) == 0) {
node->removeChild(child);
break;
}
}
break;
}
}
}
item = new QTreeWidgetItem(parent);
item->setIcon(0, QIcon(pixmap));
item->setText(1, label);
item->setText(2, extension);
item->setText(3, key);
item->setFlags(item->flags() | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled);
setCurrentItem(item);
if (key.length() > 0)
emit itemMoved(key, parent->text(1));
eventAccept = true;
} else {
bool flag = true;
if (parent->isExpanded())
flag = false;
parent->setExpanded(flag);
}
} else {
if (parentNode.length() > 0) {
QList<QTreeWidgetItem *> nodes = findItems(parentNode, Qt::MatchExactly, 1);
for (int i = 0; i < nodes.size(); ++i) {
QTreeWidgetItem *node = nodes.at(i);
if (node->text(1).compare(parentNode) == 0) {
int childrenTotal = node->childCount();
for (int i=0;i < childrenTotal; i++) {
QTreeWidgetItem *child = node->child(i);
if (child->text(1).compare(label) == 0 && child->text(2).compare(extension) == 0) {
node->removeChild(child);
break;
}
}
break;
}
}
} else {
if (extension.length() == 0 && nodeChildren.size() > 0)
return;
}
item = new QTreeWidgetItem(this);
item->setIcon(0, QIcon(pixmap));
item->setText(1, label);
item->setText(2, extension);
item->setText(3, key);
item->setFlags(item->flags() | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled);
setCurrentItem(item);
emit itemMoved(key, "");
eventAccept = true;
}
} else {
void VSCDeviceList::DelIPCameraByGroup(s32 nId)
{
DeviceParam pParam;
QTreeWidgetItem *qtreewidgetitem = ui.treeWidget->topLevelItem(VSC_DEVICE_INDEX_IPC);
bool deled = false;
gFactory->GetDeviceParamById(pParam, nId);
if (pParam.m_Conf.data.conf.GroupId == 0)
{
int cnt = qtreewidgetitem->childCount();
//VDC_DEBUG( "%s cnt %d\n",__FUNCTION__, cnt);
for (int i = 0; i < cnt; i ++)
{
QTreeWidgetItem * pChild = qtreewidgetitem->child(i);
VSCDeviceIPC *pIPC = dynamic_cast<VSCDeviceIPC*>(pChild);
if (pIPC && pIPC->GetDeviceId() == nId)
{
qtreewidgetitem->removeChild(pChild);
deled = true;
}
}
}
if (deled == false)
{
/* loop for del to the group */
int cnt = qtreewidgetitem->childCount();
for (int i = 0; i < cnt; i ++)
{
QTreeWidgetItem * pChild = qtreewidgetitem->child(i);
VSCDeviceIPCGroup *pGroup = dynamic_cast<VSCDeviceIPCGroup*>(pChild);
if (pGroup)
{
int cnt2 = pChild->childCount();
//VDC_DEBUG( "%s cnt %d\n",__FUNCTION__, cnt);
for (int j = 0; j < cnt2; j ++)
{
QTreeWidgetItem * pChild2 = pChild->child(j);
VSCDeviceIPC *pIPC = dynamic_cast<VSCDeviceIPC*>(pChild2);
if (pIPC && pIPC->GetDeviceId() == nId)
{
pChild->removeChild(pChild2);
deled = true;
}
}
}
}
}
if (deled == false)
{
int cnt = qtreewidgetitem->childCount();
//VDC_DEBUG( "%s cnt %d\n",__FUNCTION__, cnt);
for (int i = 0; i < cnt; i ++)
{
QTreeWidgetItem * pChild = qtreewidgetitem->child(i);
VSCDeviceIPC *pIPC = dynamic_cast<VSCDeviceIPC*>(pChild);
if (pIPC && pIPC->GetDeviceId() == nId)
{
qtreewidgetitem->removeChild(pChild);
deled = true;
}
}
}
return;
}
