void QgsComposerLegendWidget::on_mMoveUpToolButton_clicked()
{
if ( !mLegend )
{
return;
}
QStandardItemModel* itemModel = qobject_cast<QStandardItemModel *>( mItemTreeView->model() );
if ( !itemModel )
{
return;
}
QModelIndex currentIndex = mItemTreeView->currentIndex();
if ( !currentIndex.isValid() )
{
return;
}
mLegend->beginCommand( "Moved legend item up" );
//is there an older sibling?
int row = currentIndex.row();
QModelIndex olderSibling = currentIndex.sibling( row - 1, 0 );
if ( !olderSibling.isValid() )
{
return;
}
QModelIndex parentIndex = currentIndex.parent();
QList<QStandardItem*> itemToMove;
QList<QStandardItem*> olderSiblingItem;
if ( !parentIndex.isValid() ) //move toplevel item
{
itemToMove = itemModel->takeRow( row );
olderSiblingItem = itemModel->takeRow( row - 1 );
itemModel->insertRow( row - 1, itemToMove );
itemModel->insertRow( row, olderSiblingItem );
}
else //move classification items
{
QStandardItem* parentItem = itemModel->itemFromIndex( parentIndex );
itemToMove = parentItem->takeRow( row );
olderSiblingItem = parentItem->takeRow( row - 1 );
parentItem->insertRow( row - 1, itemToMove );
parentItem->insertRow( row, olderSiblingItem );
}
mItemTreeView->setCurrentIndex( itemModel->indexFromItem( itemToMove.at( 0 ) ) );
mLegend->update();
mLegend->endCommand();
}
void QgsComposerLegendWidget::on_mMoveDownPushButton_clicked()
{
QStandardItemModel* itemModel = dynamic_cast<QStandardItemModel*>( mItemTreeView->model() );
if ( !itemModel )
{
return;
}
QModelIndex currentIndex = mItemTreeView->currentIndex();
if ( !currentIndex.isValid() )
{
return;
}
//is there an older sibling?
int row = currentIndex.row();
QModelIndex youngerSibling = currentIndex.sibling( row + 1, 0 );
if ( !youngerSibling.isValid() )
{
return;
}
QModelIndex parentIndex = currentIndex.parent();
QList<QStandardItem*> itemToMove;
QList<QStandardItem*> youngerSiblingItem;
if ( !parentIndex.isValid() ) //move toplevel (layer) item
{
youngerSiblingItem = itemModel->takeRow( row + 1 );
itemToMove = itemModel->takeRow( row );
itemModel->insertRow( row, youngerSiblingItem );
itemModel->insertRow( row + 1, itemToMove );
}
else //move child (classification) item
{
QStandardItem* parentItem = itemModel->itemFromIndex( parentIndex );
youngerSiblingItem = parentItem->takeRow( row + 1 );
itemToMove = parentItem->takeRow( row );
parentItem->insertRow( row, youngerSiblingItem );
parentItem->insertRow( row + 1, itemToMove );
}
mItemTreeView->setCurrentIndex( itemModel->indexFromItem( itemToMove.at( 0 ) ) );
if ( mLegend )
{
mLegend->update();
}
}
bool QgsLegendModel::removeRows( int row, int count, const QModelIndex & parent )
{
if ( count < 1 )
{
return false;
}
if ( parent.isValid() )
{
for ( int i = row + count - 1; i >= row; --i )
{
QStandardItem* item = itemFromIndex( parent );
if ( item )
{
item->takeRow( i );
}
}
}
else
{
for ( int i = row + count - 1; i >= row; --i )
{
takeRow( i );
}
}
return true;
}
void
mail_item_model::remove_msg(mail_msg* msg)
{
DBG_PRINTF(8, "remove_msg(mail_id=" MAIL_ID_FMT_STRING ")", msg->get_id());
QMap<mail_id_t, QStandardItem*>::iterator it = items_map.find(msg->get_id());
if (it!=items_map.end()) {
QStandardItem* item = it.value();
QStandardItem* parent_item = item->parent();
while (item->child(0,0)!=NULL) {
// reparent childs of the item to remove
QList<QStandardItem*> ql = item->takeRow(0);
if (parent_item) {
DBG_PRINTF(9, "reparenting child to immediate parent row=%d", item->index().row());
parent_item->insertRow(item->index().row(), ql);
}
else {
DBG_PRINTF(9, "reparenting child to root");
insertRow(item->index().row(), ql);
}
}
//
DBG_PRINTF(9, "removing mail_id=" MAIL_ID_FMT_STRING
" from model at index.row=%d index.column=%d",
msg->get_id(), item->index().row(),
item->index().column());
QModelIndex index = item->index();
removeRow(index.row(), index.parent());
items_map.erase(it);
}
else {
DBG_PRINTF(1, "ERR: mail_id=" MAIL_ID_FMT_STRING " not found in items_map", msg->get_id());
}
}
void list_handling::compare_downloads(QModelIndex &index, std::vector<package>::iterator &new_it, std::vector<package>::iterator &old_it, vector<view_info> &info){
int dl_line = 0;
vector<download>::iterator old_dit = old_it->dls.begin();
vector<download>::iterator new_dit = new_it->dls.begin();
vector<view_info>::iterator vit;
QStandardItem *pkg;
QStandardItem *dl;
pkg = list_model->itemFromIndex(index);
if(pkg == NULL)
return;
// compare every single download of the package
while((old_dit != old_it->dls.end()) && (new_dit != new_it->dls.end())){
compare_one_download(*new_dit, *old_dit, pkg, dl_line);
// recreate selection if existed
for(vit = info.begin(); vit != info.end(); ++vit){
if((vit->id == new_dit->id) && !(vit->package)){
if(vit->selected){ // download is selected
for(int i=0; i<5; ++i)
selection_model->select(index.child(dl_line, i), QItemSelectionModel::Select);
selected_downloads_size += (double)new_dit->size / 1048576;
++selected_downloads_count;
break;
}
}
}
++old_dit;
++new_dit;
++dl_line;
}
if(old_dit != old_it->dls.end()){ // there are more old lines than new ones
while(old_dit != old_it->dls.end()){
// delete packages out of model
for(int i=0; i<5; ++i){
dl = pkg->takeChild(dl_line, i);
delete dl;
}
pkg->takeRow(dl_line);
++old_dit;
}
}else if(new_dit != new_it->dls.end()){ // there are more new lines than old ones
while(new_dit != new_it->dls.end()){
// insert new download linkes
create_new_download(*new_dit, pkg, dl_line);
++dl_line;
++new_dit;
}
list->collapse(index);
list->expand(index);
}
}
void AbstractCameraManager::removeGroup(QModelIndex index) {
QStandardItem * item = getModel()->itemFromIndex( index );
if( !item->isEditable() ) return;
QStandardItem * parent = item->parent();
if( parent == NULL ) parent = item->model()->invisibleRootItem();
for(int i=item->rowCount(); i>0; i--) {
newCameraList.insertRow(0, item->takeRow(0));
}
parent->removeRow( item->row() );
detectNewCamerasAndExpand();
}
/**
Updates the sibling position of the item, depending on the position in the model.
*/
void NavigatorTreeModel::updateItemRowOrder(const ModelNode &node)
{
if (!containsNode(node))
return;
ItemRow itemRow = itemRowForNode(node);
int currentRow = itemRow.idItem->row();
int newRow = currentRow;
if (node.parentProperty().parentModelNode().isValid())
newRow = modelNodeChildren(node.parentProperty().parentModelNode()).indexOf(node);
Q_ASSERT(newRow >= 0);
if (currentRow != newRow) {
QStandardItem *parentIdItem = itemRow.idItem->parent();
QList<QStandardItem*> items = parentIdItem->takeRow(currentRow);
parentIdItem->insertRow(newRow, items);
}
}
void EventViewer::deleteAllChildren(QStandardItem * parent)
{
//delete all children of eventsItem;
QStandardItem * loopItem = parent; //main loop item
QList<QStandardItem *> carryItems; //Last In First Out stack of items
QList<QStandardItem *> itemsToBeDeleted; //List of items to be deleted
while (loopItem->rowCount())
{
itemsToBeDeleted << loopItem->takeRow(0);
//if the row removed has children:
if (itemsToBeDeleted.at(0)->hasChildren())
{
carryItems << loopItem; //put on the stack the current loopItem
loopItem = itemsToBeDeleted.at(0); //set the row with children as the loopItem
}
//if current loopItem has no more rows but carryItems list is not empty:
if (!loopItem->rowCount() && !carryItems.isEmpty()) loopItem = carryItems.takeFirst();
}
qDeleteAll(itemsToBeDeleted);
}
void QgsEffectStackPropertiesWidget::moveEffectByOffset( int offset )
{
EffectItem *item = currentEffectItem();
if ( !item )
return;
int row = item->row();
QStandardItem* root = mModel->invisibleRootItem();
int layerIdx = root->rowCount() - row - 1;
// switch effects
QgsPaintEffect* tmpEffect = mStack->takeEffect( layerIdx );
mStack->insertEffect( layerIdx - offset, tmpEffect );
QList<QStandardItem *> toMove = root->takeRow( row );
root->insertRows( row + offset, toMove );
QModelIndex newIdx = toMove[ 0 ]->index();
mEffectsList->setCurrentIndex( newIdx );
updatePreview();
updateUi();
}
void FileOrganiserWidget::moveItem(QStandardItem *pItem,
QStandardItem *pDropItem,
const QAbstractItemView::DropIndicatorPosition &pDropPosition)
{
if (!pDropItem)
// pDropItem is not valid, so...
return;
// Move pItem above/on/below pDropItem, depending on the drop position, but
// first, determine the item that will own pItem
QStandardItem *crtParentItem = pItem->parent()?
pItem->parent():
mModel->invisibleRootItem();
QStandardItem *newParentItem = parentItem(pDropItem, pDropPosition);
// Second, check whether the (file) item points to a file which is already
// owned by newParentItem
bool fileAlreadyOwned = false;
if (!pItem->data(Item::Folder).toBool())
// The current item is a file item, so retrieve its file name and check
// whether it's already owned by newParentItem
fileAlreadyOwned = ownedBy(pItem->data(Item::Path).toString(), newParentItem);
// Third, move pItem to newParentItem and this to the right place, depending
// on the value of pDropPosition and only if the destination doesn't already
// have that item (should it be a file item, since folder items are always
// moved)
if (!fileAlreadyOwned || (crtParentItem == newParentItem)) {
// Either newParentItem doesn't already own an item which points to the
// same file as pItem or pItem's current parent is the same as
// newParentItem in which case it means that we want to move the item
// within its current location
// First, check whether the item is a folder and, if so, whether it's
// expanded (and the same with any (in)direct child folder it may
// contain)
backupExpandedInformation(pItem);
// Second, move the item (and any of its children)
dropItems(pDropItem, pDropPosition, newParentItem,
crtParentItem->takeRow(pItem->row()));
// Third, re-expand folders, if necessary
restoreExpandedInformation(pItem);
// Fourth, resize the widget, just in case the new location of the
// item(s) requires more space than is visible
resizeToContents();
} else {
// A (file) item pointing to the same file is already owned by
// newParentItem, so just remove the item rather than move it
crtParentItem->removeRow(pItem->row());
}
}
void Model::apply(std::shared_ptr<Core::MutationInfo> mutation) noexcept
{
emit documentMutated(&mutation->prev, &mutation->cur);
// Update the pointers stored in the model items
using NodeOrProperty = eggs::variant<NodePtr, PropertyPtr>;
std::unordered_map<NodeOrProperty, NodeOrProperty> mutated;
auto updatePointers = [&](auto& changes)
{
for (auto&& mut: changes)
{
if (mut.type != ChangeType::Mutated) continue;
findItem(mut.prev)->update(mut.cur);
mutated.insert({ mut.prev, mut.cur });
}
};
updatePointers(mutation->nodes);
updatePointers(mutation->properties);
auto resolve = [&](auto item) -> decltype(item)
{
if (!item) return item;
auto it = mutated.find(item);
#ifdef _MSC_VER
if (it != cend(mutated)) return *it->second.target<decltype(item)>();
#else
if (it != cend(mutated)) return *it->second.template target<decltype(item)>();
#endif
return item;
};
enum class RowType { Node, Property };
auto setRow = [&](QStandardItem* parent, size_t row, QList<QStandardItem*> items, RowType rowType)
{
if (rowType == RowType::Property)
{
// Properties are indexed from 0, but they should always go below the node children of the parent
// So increase the row offset by the number of children the parent has
row += mutation->cur.childCount(*ModelItem::node(parent));
}
// When inserting a new item, make sure we above any items that have a higher index in the actual document
// If we are inserting a node, also make sure we stay above any properties
auto maxRow = row;
for (row = 0; row < maxRow; row++)
{
if (row == static_cast<size_t>(parent->rowCount())) break;
auto child = parent->child(row);
// Encountered a property, so stop
if (rowType == RowType::Node && ModelItem::prop(child)) break;
size_t index;
// Encountered a property that has a higher index than this item, so stop
auto prop = ModelItem::prop(child);
if (prop)
{
auto propNode = mutation->cur.parent(*prop);
// add node childCount because the properties start BELOW the child nodes
index = mutation->cur.childIndex(*prop) + mutation->cur.childCount(*propNode);
if (index > maxRow) break;
}
// Encountered a node that has a higher index than this item, so stop
auto node = ModelItem::node(child);
if (node)
{
index = mutation->cur.childIndex(*node);
if (index > maxRow) break;
}
}
//LOG->debug("row: {}, rowCount: {}", row, parent->rowCount());
if (row <= static_cast<size_t>(parent->rowCount())) parent->insertRow(row, items);
else parent->appendRow(items);
};
auto applyMutations = [&](auto& changes, RowType rowType, auto createItems, bool onlyRemove)
{
for (auto&& mut : changes)
{
QStandardItem* prevParentNode = findItem(resolve(mut.prevParent));
if (!prevParentNode && rowType == RowType::Node) prevParentNode = invisibleRootItem();
QStandardItem* curParentNode = findItem(resolve(mut.curParent));
if (!curParentNode && rowType == RowType::Node) curParentNode = invisibleRootItem();
switch (mut.type)
{
case ChangeType::Added:
{
if (onlyRemove) continue;
LOG->debug("Adding at position {}: {}", mut.curIndex, *mut.cur);
setRow(curParentNode, mut.curIndex, createItems(mut.cur), rowType);
break;
}
case ChangeType::Removed:
{
if (!onlyRemove) continue;
auto item = findItem(mut.prev);
if (!item) continue; // maybe was already deleted when parent was removed
auto childIndex = findChildIndex(prevParentNode, item);
if (childIndex != -1) prevParentNode->removeRow(childIndex);
LOG->debug("Removed at position {}: {}", childIndex, *mut.prev);
break;
}
case ChangeType::Mutated:
{
if (onlyRemove) continue;
assert(prevParentNode && curParentNode);
LOG->debug("Mutating from position {} to position {}: {}", mut.prevIndex, mut.curIndex, *mut.cur);
auto nodeOrProperty = resolve(mut.prev);
auto item = findItem(nodeOrProperty);
assert(item);
auto prevIndex = findChildIndex(prevParentNode, item);
assert(prevIndex != -1);
if (prevIndex != mut.curIndex || prevParentNode != curParentNode)
{
// Move the row
auto itemRowItems = prevParentNode->takeRow(prevIndex);
setRow(curParentNode, mut.curIndex, itemRowItems, rowType);
}
break;
}
}
}
};
auto createNodeItems = [&](NodePtr node)
{
QList<QStandardItem*> items;
items << new ModelItem(this, node) << nullptr;
return items;
};
auto createPropertyItems = [&](PropertyPtr prop)
{
QList<QStandardItem*> items;
auto modelItem = new ModelItem(this, prop);
items << modelItem << modelItem->propertyValueItem();
return items;
};
applyMutations(mutation->nodes, RowType::Node, createNodeItems, false);
applyMutations(mutation->properties, RowType::Property, createPropertyItems, false);
applyMutations(mutation->nodes, RowType::Node, createNodeItems, true);
applyMutations(mutation->properties, RowType::Property, createPropertyItems, true);
}