/*! this implementation ignores column positions (sometimes used in QTreeViews but not in our QGraphicsScene frontend) */
bool ObjectPool::compareIndexes ( const QPersistentModelIndex & a, const QPersistentModelIndex & b ) {
if ( a.row() != b.row() )
return false;
if ( a.internalPointer() != b.internalPointer() )
return false;
return true;
}
//-----------------------------------------------------------------------------
void ctkModelTester::testPersistentModelIndex(const QPersistentModelIndex& index)const
{
CTK_D(const ctkModelTester);
//qDebug() << "Test persistent Index: " << index ;
this->test(index.isValid(), "Persistent model index can't be invalid");
// did you forget to call QAbstractItemModel::changePersistentIndex() between
// beginLayoutChanged() and changePersistentIndex() ?
QModelIndex modelIndex = d->Model->index(index.row(), index.column(), index.parent());
this->test(modelIndex == index,
QString("Persistent index (%1, %2) can't be invalid").arg(index.row()).arg(index.column()));
}
void PersonsModel::removePerson(const QString& id)
{
Q_D(PersonsModel);
QPersistentModelIndex index = d->personIndex.value(id);
if (!index.isValid()) { //item not found
return;
}
beginRemoveRows(QModelIndex(), index.row(), index.row());
d->personIndex.remove(id);
d->metacontacts.removeAt(index.row());
endRemoveRows();
}
void MicroblogDelegate::updateItemWidgets( const QList<QWidget*> widgets,
const QStyleOptionViewItem &option,
const QPersistentModelIndex &index ) const
{
Q_UNUSED( option );
if ( !index.isValid() ) {
return;
}
const BlogModel* model = static_cast<const BlogModel*>( index.model() );
int row = index.row();
QWebView *edit = static_cast<QWebView*>( widgets[0] );
edit->page()->setLinkDelegationPolicy( QWebPage::DelegateAllLinks );
edit->move( 5, 5 );
edit->resize( 400,200 );
QString text;
text.append( "<table><tr><td><img src=\"" + this->getData( model, row, BlogModel::Picture ).toString() + "\"></td>" );
text.append( "<td>" + getData( model, row, BlogModel::Date ).toString() );
text.append( "<Br>" + getData( model, row, BlogModel::User ).toString() );
text.append( "</td></tr></table>" );
text.append( "<Br>" + getData( model, row, BlogModel::Text ).toString() );
//kDebug() << text;
edit->setHtml( text );
}
void GraphicalModelAssistApi::removeElement(const Id &graphicalId)
{
const QPersistentModelIndex index = indexById(graphicalId);
if (graphicalRepoApi().exist(graphicalId) && index.isValid()) {
mGraphicalModel.removeRow(index.row(), index.parent());
}
}
void
TransferView::onTransferUpdate()
{
StreamConnection* sc = (StreamConnection*)sender();
// qDebug() << Q_FUNC_INFO << sc->track().isNull() << sc->source().isNull();
if ( sc->track().isNull() || sc->source().isNull() )
return;
QTreeWidgetItem* ti = 0;
if ( m_index.contains( sc ) )
{
QPersistentModelIndex i = m_index.value( sc );
ti = m_tree->invisibleRootItem()->child( i.row() );
}
else
{
ti = new QTreeWidgetItem( m_tree );
m_index.insert( sc, QPersistentModelIndex( m_tree->model()->index( m_tree->invisibleRootItem()->childCount() - 1, 0 ) ) );
emit showWidget();
}
if ( !ti )
return;
ti->setText( 0, sc->source()->friendlyName() );
ti->setText( 1, QString( "%1 kb/s" ).arg( sc->transferRate() / 1024 ) );
ti->setText( 2, QString( "%1 - %2" ).arg( sc->track()->artist()->name() ).arg( sc->track()->track() ) );
if ( isHidden() )
emit showWidget();
}
void ModelTest::layoutChanged()
{
for ( int i = 0; i < changing.count(); ++i ) {
QPersistentModelIndex p = changing[i];
Q_ASSERT ( p == model->index ( p.row(), p.column(), p.parent() ) );
}
changing.clear();
}
void Helper::layoutChanged()
{
for ( int i = 0; i < changing.count(); ++i ) {
QPersistentModelIndex p = changing[i];
QVERIFY( p == model->index ( p.row(), p.column(), p.parent() ) );
}
changing.clear();
}
void tst_QAbstractItemModel::movePersistentIndex()
{
QtTestModel model(3, 3);
QPersistentModelIndex a = model.index(1, 1);
QVERIFY(a.isValid());
QCOMPARE(a.row(), 1);
QCOMPARE(a.column(), 1);
model.insertRow(0);
QCOMPARE(a.row(), 2);
model.insertRow(1);
QCOMPARE(a.row(), 3);
model.insertColumn(0);
QCOMPARE(a.column(), 2);
}
int ScriptableProxyHelper::currentItem()
{
INVOKE(currentItem());
if (!canUseSelectedItems())
return -1;
const QPersistentModelIndex current =
m_actionData.value(mimeCurrentItem).value<QPersistentModelIndex>();
return current.isValid() ? current.row() : -1;
}
void QuickItemDelegate::setTextColor(const QVariant &textColor, const QPersistentModelIndex &index)
{
if (!index.isValid())
return;
m_colors[index] = textColor.value<QColor>();
for (int i = 0; i < m_view->model()->columnCount(); i++)
m_view->update(index.sibling(index.row(), i));
}
void MOTableView::startDrag(Qt::DropActions supportedActions)
{
qDebug() << "MOTableView::startDrag; begin";
QModelIndexList indexes = selectedIndexes();
QList<QPersistentModelIndex> persistentIndexes;
if (indexes.count() > 0) {
QMimeData *data = model()->mimeData(indexes);
if (!data)
return;
for (int i = 0; i<indexes.count(); i++){
QModelIndex idx = indexes.at(i);
persistentIndexes.append(QPersistentModelIndex(idx));
}
QPixmap pixmap = indexes.first().data(Qt::DecorationRole).value<QPixmap>();
QDrag *drag = new QDrag(this);
drag->setPixmap(pixmap);
drag->setMimeData(data);
drag->setHotSpot(QPoint(pixmap.width()/2, pixmap.height()/2));
Qt::DropAction defaultDropAction = Qt::IgnoreAction;
if (supportedActions & Qt::MoveAction && dragDropMode() != QAbstractItemView::InternalMove)
defaultDropAction = Qt::MoveAction; //was Qt::CopyAction THIS WAS THE CULPRIT!
if ( drag->exec(supportedActions, defaultDropAction) == Qt::MoveAction ){
//when we get here any copying done in dropMimeData has messed up our selected indexes
//that's why we use persistent indexes
for (int i = 0; i<indexes.count(); i++){
QPersistentModelIndex idx = persistentIndexes.at(i);
if (idx.isValid()){ //the item is not top level
model()->removeRow(idx.row(), idx.parent());
}
else{
model()->removeRow(idx.row(), QModelIndex());
}
}
}
}
qDebug() << "MOTableView::startDrag; end";
}
void TestRGTagModel::testModel3()
{
SimpleTreeModel* const treeModel = new SimpleTreeModel(1, this);
new ModelTest(treeModel, this);
// add some items before the tagModel is created:
SimpleTreeModel::Item* const treeItem1 = treeModel->addItem();
const QPersistentModelIndex treeItem1Index = treeModel->itemToIndex(treeItem1);
SimpleTreeModel::Item* const treeItem11 = treeModel->addItem(treeItem1);
const QPersistentModelIndex treeItem11Index = treeModel->itemToIndex(treeItem11);
SimpleTreeModel::Item* const treeItem2 = treeModel->addItem();
const QPersistentModelIndex treeItem2Index = treeModel->itemToIndex(treeItem2);
KIPIGPSSyncPlugin::RGTagModel* const tagModel = new KIPIGPSSyncPlugin::RGTagModel(treeModel, this);
// modeltest will be created at the end of this function to make sure it does not influence the result!
// first, verify the row and column counts:
QCOMPARE(tagModel->rowCount(QModelIndex()), 2);
QCOMPARE(tagModel->columnCount(QModelIndex()), 1);
// now test toSourceIndex:
const QModelIndex tagItem1Index = tagModel->index(0, 0);
// now add a new item to the source model, before the existing item:
SimpleTreeModel::Item* const treeItem11a = treeModel->addItem(treeItem1, 0);
const QPersistentModelIndex treeItem11aIndex = treeModel->itemToIndex(treeItem11a);
QCOMPARE(treeItem11Index.row(), 1);
QCOMPARE(treeItem11aIndex.row(), 0);
// now add a new item to the source model, this time in the middle:
SimpleTreeModel::Item* const treeItem11b = treeModel->addItem(treeItem1, 1);
const QPersistentModelIndex treeItem11bIndex = treeModel->itemToIndex(treeItem11b);
QCOMPARE(treeItem11Index.row(), 2);
QCOMPARE(treeItem11aIndex.row(), 0);
QCOMPARE(treeItem11bIndex.row(), 1);
// add modeltest as the last test:
new ModelTest(tagModel, this);
}
void QuickItemDelegate::setTextColor(const QVariant &textColor)
{
const QPersistentModelIndex index = sender()->property("index").value<QPersistentModelIndex>();
if (!index.isValid()) {
return;
}
m_colors[index] = textColor.value<QColor>();
for (int i = 0; i < m_view->model()->columnCount(); i++) {
m_view->update(index.sibling(index.row(), i));
}
}
void EditorViewMViface::handleAddingSequenceForRowsInserted(const QModelIndex &parent
, Element *elem, const QPersistentModelIndex ¤t)
{
if (item(parent)) {
elem->setParentItem(item(parent));
QModelIndex next = current.sibling(current.row() + 1, 0);
if(next.isValid() && item(next) != nullptr) {
elem->stackBefore(item(next));
}
} else {
mScene->addItem(elem);
}
}
//-----------------------------------------------------------------------------
void ctkModelTester::onItemsAboutToBeRemoved(const QModelIndex &vparent, Qt::Orientation orientation, int start, int end)
{
CTK_D(ctkModelTester);
this->test(start <= end, "Start can't be higher than end");
//Not sure about that
this->test(d->AboutToBeInserted.size() == 0, "While inserting items, you can't remove other items.");
//Not sure about that
this->test(d->AboutToBeRemoved.size() == 0, "While removing items, you can't remove other items.");
int count = (orientation == Qt::Vertical ? d->Model->rowCount(vparent) :d->Model->columnCount(vparent) );
this->test(start < count, "Item to remove can't be invalid");
this->test(end < count, "Item to remove can't be invalid");
ctkModelTesterPrivate::Change change;
change.Parent = vparent;
change.Orientation = orientation;
change.Start = start;
change.End = end;
change.Count = count;
for (int i = 0 ; i < count; ++i)
{
QPersistentModelIndex index;
index = (orientation == Qt::Vertical ? d->Model->index(i, 0, vparent) : d->Model->index(0, i, vparent));
this->test(index.isValid(), "Index invalid");
if (orientation == Qt::Vertical && (index.row() < start || index.row() > end))
{
change.Items.append(index);
}
if (orientation == Qt::Horizontal && (index.column() < start || index.column() > end))
{
change.Items.append(index);
}
}
d->AboutToBeRemoved.push(change);
this->testModel();
//qDebug() << "About to be removed: " << start << " " << end <<vparent << count << change.Items.count();
}
QModelIndex UIBootTable::moveItemTo(const QModelIndex &index, int row)
{
if (!index.isValid())
return QModelIndex();
if (row < 0 || row > model()->rowCount())
return QModelIndex();
QPersistentModelIndex oldIndex(index);
UIBootTableItem *pItem = static_cast<UIBootTableItem*>(itemFromIndex(oldIndex));
insertItem(row, new UIBootTableItem(*pItem));
QPersistentModelIndex newIndex = model()->index(row, 0);
delete takeItem(oldIndex.row());
setCurrentRow(newIndex.row());
return QModelIndex(newIndex);
}
static PyObject *meth_QPersistentModelIndex_row(PyObject *sipSelf, PyObject *sipArgs)
{
PyObject *sipParseErr = NULL;
{
QPersistentModelIndex *sipCpp;
if (sipParseArgs(&sipParseErr, sipArgs, "B", &sipSelf, sipType_QPersistentModelIndex, &sipCpp))
{
int sipRes;
Py_BEGIN_ALLOW_THREADS
sipRes = sipCpp->row();
Py_END_ALLOW_THREADS
return SIPLong_FromLong(sipRes);
}
}
void
TransferView::streamFinished( StreamConnection* sc )
{
if ( !m_index.contains( sc ) )
return;
QPersistentModelIndex i = m_index.take( sc );
delete m_tree->invisibleRootItem()->takeChild( i.row() );
if ( m_tree->invisibleRootItem()->childCount() > 0 )
emit showWidget();
else
emit hideWidget();
/* if ( m_index.contains( sc ) )
{
int i = m_index.value( sc );
m_tree->invisibleRootItem()->child( i )->setText( 1, tr( "Finished" ) );
}*/
}
void VisualMusicModel::itemRowSequenceChanged(VisualItem *visualItem)
{
if (!(visualItem->graphicalType() == VisualItem::GraphicalRowType))
return;
if (!m_visualItemIndexes.values().contains(visualItem))
return;
int scoreRow = 0;
QPersistentModelIndex index = m_visualItemIndexes.key(visualItem);
switch (visualItem->itemType()) {
case VisualItem::NoVisualItem:
break;
case VisualItem::VisualScoreItem: {
scoreRow = index.row();
break;
}
case VisualItem::VisualTuneItem: {
scoreRow = index.parent().row();
break;
}
case VisualItem::VisualPartItem: {
scoreRow = index.parent().parent().row();
break;
}
case VisualItem::VisualMeasureItem: {
scoreRow = index.parent().parent().parent().row();
break;
}
case VisualItem::VisualSymbolItem: {
scoreRow = index.parent().parent().parent().parent().row();
break;
}
}
emit scoreRowSequenceChanged(scoreRow);
}
QModelIndex cast( NifModel * nif, const QModelIndex & index ) override final
{
QPersistentModelIndex idx = index;
QPersistentModelIndex iData = nif->getBlock( nif->getLink( idx, "Data" ), "NiTriShapeData" );
if ( !iData.isValid() )
return idx;
QVector<Triangle> triangles;
QModelIndex iTriangles = nif->getIndex( iData, "Triangles" );
if ( !iTriangles.isValid() )
return idx;
int skip = 0;
for ( int t = 0; t < nif->rowCount( iTriangles ); t++ ) {
Triangle tri = nif->get<Triangle>( iTriangles.child( t, 0 ) );
if ( tri[0] != tri[1] && tri[1] != tri[2] && tri[2] != tri[0] )
triangles.append( tri );
else
skip++;
}
//qDebug() << "num triangles" << triangles.count() << "skipped" << skip;
QList<QVector<quint16> > strips = stripify( triangles );
if ( strips.count() <= 0 )
return idx;
nif->insertNiBlock( "NiTriStripsData", nif->getBlockNumber( idx ) + 1 );
QModelIndex iStripData = nif->getBlock( nif->getBlockNumber( idx ) + 1, "NiTriStripsData" );
if ( iStripData.isValid() ) {
copyValue<int>( nif, iStripData, iData, "Num Vertices" );
nif->set<int>( iStripData, "Has Vertices", 1 );
copyArray<Vector3>( nif, iStripData, iData, "Vertices" );
copyValue<int>( nif, iStripData, iData, "Has Normals" );
copyArray<Vector3>( nif, iStripData, iData, "Normals" );
copyValue<int>( nif, iStripData, iData, "TSpace Flag" );
copyArray<Vector3>( nif, iStripData, iData, "Bitangents" );
copyArray<Vector3>( nif, iStripData, iData, "Tangents" );
copyValue<int>( nif, iStripData, iData, "Has Vertex Colors" );
copyArray<Color4>( nif, iStripData, iData, "Vertex Colors" );
copyValue<int>( nif, iStripData, iData, "Has UV" );
copyValue<int>( nif, iStripData, iData, "Num UV Sets" );
copyValue<int>( nif, iStripData, iData, "BS Num UV Sets" );
copyValue<int>( nif, iStripData, iData, "Num UV Sets 2" );
QModelIndex iDstUV = nif->getIndex( iStripData, "UV Sets" );
QModelIndex iSrcUV = nif->getIndex( iData, "UV Sets" );
if ( iDstUV.isValid() && iSrcUV.isValid() ) {
nif->updateArray( iDstUV );
for ( int r = 0; r < nif->rowCount( iDstUV ); r++ ) {
copyArray<Vector2>( nif, iDstUV.child( r, 0 ), iSrcUV.child( r, 0 ) );
}
}
iDstUV = nif->getIndex( iStripData, "UV Sets 2" );
iSrcUV = nif->getIndex( iData, "UV Sets 2" );
if ( iDstUV.isValid() && iSrcUV.isValid() ) {
nif->updateArray( iDstUV );
for ( int r = 0; r < nif->rowCount( iDstUV ); r++ ) {
copyArray<Vector2>( nif, iDstUV.child( r, 0 ), iSrcUV.child( r, 0 ) );
}
}
copyValue<Vector3>( nif, iStripData, iData, "Center" );
copyValue<float>( nif, iStripData, iData, "Radius" );
nif->set<int>( iStripData, "Num Strips", strips.count() );
nif->set<int>( iStripData, "Has Points", 1 );
QModelIndex iLengths = nif->getIndex( iStripData, "Strip Lengths" );
QModelIndex iPoints = nif->getIndex( iStripData, "Points" );
if ( iLengths.isValid() && iPoints.isValid() ) {
nif->updateArray( iLengths );
nif->updateArray( iPoints );
int x = 0;
int z = 0;
for ( const QVector<quint16>& strip : strips ) {
nif->set<int>( iLengths.child( x, 0 ), strip.count() );
QModelIndex iStrip = iPoints.child( x, 0 );
nif->updateArray( iStrip );
nif->setArray<quint16>( iStrip, strip );
x++;
z += strip.count() - 2;
}
nif->set<int>( iStripData, "Num Triangles", z );
nif->setData( idx.sibling( idx.row(), NifModel::NameCol ), "NiTriStrips" );
int lnk = nif->getLink( idx, "Data" );
nif->setLink( idx, "Data", nif->getBlockNumber( iStripData ) );
nif->removeNiBlock( lnk );
}
}
return idx;
}
void EditorViewMViface::rowsInserted(QModelIndex const &parent, int start, int end)
{
for (int row = start; row <= end; ++row) {
mScene->setEnabled(true);
QPersistentModelIndex current = model()->index(row, 0, parent);
if (!isDescendentOf(current, rootIndex()))
continue;
Id currentId = current.data(roles::idRole).value<Id>();
if (currentId == Id::rootId())
continue;
Id parentUuid;
if (parent != rootIndex())
parentUuid = parent.data(roles::idRole).value<Id>();
if (!parent.isValid()) {
setRootIndex(current);
continue;
}
Element* elem = mScene->mainWindow()->manager()->graphicalObject(currentId);
if (elem) {
elem->setAssistApi(mGraphicalAssistApi, mLogicalAssistApi);
}
QPointF ePos = model()->data(current, roles::positionRole).toPointF();
bool needToProcessChildren = true;
if (elem) {
elem->setPos(ePos); //задаем позицию до определения родителя для того, чтобы правильно отработал itemChange
elem->setId(currentId);
/*commented out because of real sizes of elements are incorrectly changing here into initial sizes*/
// NodeElement* nodeElement = dynamic_cast<NodeElement*>(elem);
// if (nodeElement)
// nodeElement->storeGeometry();
if (item(parent) != NULL) {
elem->setParentItem(item(parent));
QModelIndex next = current.sibling(current.row() + 1, 0);
if(next.isValid() && item(next) != NULL) {
elem->stackBefore(item(next));
}
} else {
mScene->addItem(elem);
}
setItem(current, elem);
elem->updateData();
elem->connectToPort();
elem->checkConnectionsToPort();
elem->initPossibleEdges();
elem->initTitles();
// elem->initEmbeddedControls();
//todo: нужно привести в порядок всякие init~()
bool isEdgeFromEmbeddedLinker = false;
QList<QGraphicsItem*> selectedItems = mScene->selectedItems();
if (selectedItems.size() == 1) {
NodeElement* master = dynamic_cast<NodeElement*>(selectedItems.at(0));
if (master && master->connectionInProgress()) {
isEdgeFromEmbeddedLinker = true;
}
}
if (!isEdgeFromEmbeddedLinker) {
mScene->clearSelection();
elem->setSelected(true);
}
NodeElement* nodeElem = dynamic_cast<NodeElement*>(elem);
if (nodeElem && currentId.element() == "Class" &&
mGraphicalAssistApi->children(currentId).empty())
{
needToProcessChildren = false;
for (int i = 0; i < 2; i++) {
QString curChildElementType;
if (i == 0)
curChildElementType = "MethodsContainer";
else
curChildElementType = "FieldsContainer";
Id newUuid = Id("Kernel_metamodel", "Kernel",
curChildElementType, QUuid::createUuid().toString());
mGraphicalAssistApi->createElement(currentId, newUuid, false, "(anonymous something)", QPointF(0, 0));
}
}
}
if (needToProcessChildren && model()->hasChildren(current))
rowsInserted(current, 0, model()->rowCount(current) - 1);
NodeElement * nodeElement = dynamic_cast<NodeElement*>(elem);
if (nodeElement)
nodeElement->alignToGrid();
}
QAbstractItemView::rowsInserted(parent, start, end);
}
void TestItemMarkerTiler::testSelectionState1()
{
QScopedPointer<QStandardItemModel> itemModel(new QStandardItemModel());
QItemSelectionModel* const selectionModel = new QItemSelectionModel(itemModel.data());
ItemMarkerTiler mm(new MarkerModelHelper(itemModel.data(), selectionModel));
const int maxLevel = TileIndex::MaxLevel;
QStandardItem* const item1 = MakeItemAt(coord_50_60);
item1->setSelectable(true);
itemModel->appendRow(item1);
QModelIndex item1Index = itemModel->indexFromItem(item1);
// verify the selection state of the tiles:
// make sure we do not create tiles all the way down,
// because we want to test whether the state is okay in newly created tiles
const int preMaxLevel = maxLevel -2;
for (int l = 0; l<=preMaxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_50_60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QVERIFY(mm.getTileMarkerCount(tileIndex) == 1);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedNone);
}
selectionModel->select(item1Index, QItemSelectionModel::Select);
// verify the selection state of the tiles:
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_50_60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 1);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedAll);
QVERIFY(mm.getTileSelectedCount(tileIndex)==1);
}
// add an unselected item and make sure the tilecount is still correct
QStandardItem* const item2 = MakeItemAt(coord_50_60);
item2->setSelectable(true);
itemModel->appendRow(item2);
const QPersistentModelIndex item2Index = itemModel->indexFromItem(item2);
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_50_60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 2);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedSome);
QCOMPARE(mm.getTileSelectedCount(tileIndex), 1);
}
selectionModel->select(item2Index, QItemSelectionModel::Select);
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_50_60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 2);
QCOMPARE(mm.getTileSelectedCount(tileIndex), 2);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedAll);
}
// now remove the selected item:
QCOMPARE(itemModel->takeRow(item2Index.row()).count(), 1);
delete item2;
// verify the selection state of the tiles:
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_50_60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 1);
QCOMPARE(mm.getTileSelectedCount(tileIndex), 1);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedAll);
}
// add a selected item and then move it:
QStandardItem* const item3 = MakeItemAt(coord_1_2);
item3->setSelectable(true);
itemModel->appendRow(item3);
const QPersistentModelIndex item3Index = itemModel->indexFromItem(item3);
selectionModel->select(item3Index, QItemSelectionModel::Select);
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_1_2, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 1);
QCOMPARE(mm.getTileSelectedCount(tileIndex), 1);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedAll);
}
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_50_60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 1);
QCOMPARE(mm.getTileSelectedCount(tileIndex), 1);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedAll);
}
itemModel->setData(item3Index, QVariant::fromValue(coord_50_60), CoordinatesRole);
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_50_60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 2);
QCOMPARE(mm.getTileSelectedCount(tileIndex), 2);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedAll);
}
itemModel->setData(item3Index, QVariant::fromValue(coord_m50_m60), CoordinatesRole);
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_50_60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 1);
QCOMPARE(mm.getTileSelectedCount(tileIndex), 1);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedAll);
}
for (int l = 0; l<=maxLevel; ++l)
{
const TileIndex tileIndex = TileIndex::fromCoordinates(coord_m50_m60, l);
ItemMarkerTiler::Tile* const myTile = mm.getTile(tileIndex, true);
QVERIFY(myTile != 0);
QCOMPARE(mm.getTileMarkerCount(tileIndex), 1);
QCOMPARE(mm.getTileSelectedCount(tileIndex), 1);
QVERIFY(mm.getTileGroupState(tileIndex)==KMapSelectedAll);
}
// TODO: set a model with selected items, make sure the selections are read out
// this is currently implemented by simply setting the tiles as dirty
}
inline int currentIdx() const
{
return orientation == Qt::Horizontal ? currentTopLeft.row() : currentTopLeft.column();
}
QModelIndex cast( NifModel * nif, const QModelIndex & index ) override final
{
QPersistentModelIndex idx = index;
QPersistentModelIndex iStripData = nif->getBlock( nif->getLink( idx, "Data" ), "NiTriStripsData" );
if ( !iStripData.isValid() )
return idx;
QList<QVector<quint16> > strips;
QModelIndex iPoints = nif->getIndex( iStripData, "Points" );
if ( !iPoints.isValid() )
return idx;
for ( int s = 0; s < nif->rowCount( iPoints ); s++ ) {
QVector<quint16> strip;
QModelIndex iStrip = iPoints.child( s, 0 );
for ( int p = 0; p < nif->rowCount( iStrip ); p++ )
strip.append( nif->get<int>( iStrip.child( p, 0 ) ) );
strips.append( strip );
}
QVector<Triangle> triangles = triangulate( strips );
nif->insertNiBlock( "NiTriShapeData", nif->getBlockNumber( idx ) + 1 );
QModelIndex iTriData = nif->getBlock( nif->getBlockNumber( idx ) + 1, "NiTriShapeData" );
if ( iTriData.isValid() ) {
copyValue<int>( nif, iTriData, iStripData, "Num Vertices" );
nif->set<int>( iTriData, "Has Vertices", 1 );
copyArray<Vector3>( nif, iTriData, iStripData, "Vertices" );
copyValue<int>( nif, iTriData, iStripData, "Has Normals" );
copyArray<Vector3>( nif, iTriData, iStripData, "Normals" );
copyValue<int>( nif, iTriData, iStripData, "TSpace Flag" );
copyArray<Vector3>( nif, iTriData, iStripData, "Bitangents" );
copyArray<Vector3>( nif, iTriData, iStripData, "Tangents" );
copyValue<int>( nif, iTriData, iStripData, "Has Vertex Colors" );
copyArray<Color4>( nif, iTriData, iStripData, "Vertex Colors" );
copyValue<int>( nif, iTriData, iStripData, "Has UV" );
copyValue<int>( nif, iTriData, iStripData, "Num UV Sets" );
copyValue<int>( nif, iTriData, iStripData, "BS Num UV Sets" );
copyValue<int>( nif, iTriData, iStripData, "Num UV Sets 2" );
QModelIndex iDstUV = nif->getIndex( iTriData, "UV Sets" );
QModelIndex iSrcUV = nif->getIndex( iStripData, "UV Sets" );
if ( iDstUV.isValid() && iSrcUV.isValid() ) {
nif->updateArray( iDstUV );
for ( int r = 0; r < nif->rowCount( iDstUV ); r++ ) {
copyArray<Vector2>( nif, iDstUV.child( r, 0 ), iSrcUV.child( r, 0 ) );
}
}
iDstUV = nif->getIndex( iTriData, "UV Sets 2" );
iSrcUV = nif->getIndex( iStripData, "UV Sets 2" );
if ( iDstUV.isValid() && iSrcUV.isValid() ) {
nif->updateArray( iDstUV );
for ( int r = 0; r < nif->rowCount( iDstUV ); r++ ) {
copyArray<Vector2>( nif, iDstUV.child( r, 0 ), iSrcUV.child( r, 0 ) );
}
}
copyValue<Vector3>( nif, iTriData, iStripData, "Center" );
copyValue<float>( nif, iTriData, iStripData, "Radius" );
nif->set<int>( iTriData, "Num Triangles", triangles.count() );
nif->set<int>( iTriData, "Num Triangle Points", triangles.count() * 3 );
nif->set<int>( iTriData, "Has Triangles", 1 );
QModelIndex iTriangles = nif->getIndex( iTriData, "Triangles" );
if ( iTriangles.isValid() ) {
nif->updateArray( iTriangles );
nif->setArray<Triangle>( iTriangles, triangles );
}
nif->setData( idx.sibling( idx.row(), NifModel::NameCol ), "NiTriShape" );
int lnk = nif->getLink( idx, "Data" );
nif->setLink( idx, "Data", nif->getBlockNumber( iTriData ) );
nif->removeNiBlock( lnk );
}
return idx;
}
void MyListWidget::mousePressEvent( QMouseEvent * event ) {
QPoint pos = event->pos();
QPersistentModelIndex index = indexAt(pos);
QString path = index.data(ROLE_ITEM_PATH).toString();
if(event->button() != Qt::LeftButton){
QPoint globalPos = QWidget::mapToGlobal(pos);
emit showOptionsMenu(path,globalPos);
//emit pressed(index);
return;
}
//Later...
//if(event->button() == Qt::RightButton){ }
QRect containingRect = this->geometry();
containingRect.setHeight(UI_DEFAULT_ITEM_HEIGHT);
containingRect.moveTop(0);
QRect pinRect = IconDelegate::getPinItemRect(containingRect);
QListWidgetItem* listWidgetItem = item(index.row());
QPoint localPos = pos;
localPos.setY(pos.y() % UI_DEFAULT_ITEM_HEIGHT);
if(pinRect.contains(localPos)){
CatItem pinItem(addPrefix(OPERATION_PREFIX,PIN_OPERATION_NAME));
if(!(listWidgetItem->data((ROLE_ITEM_PINNED)).toBool())){
listWidgetItem->setData((ROLE_ITEM_PINNED),true);
} else {listWidgetItem->setData((ROLE_ITEM_PINNED),false);}
//emit listItemAction(path, pinItem);
//frickin signal not going through
gMainWidget->operateOnItem(path,pinItem);
return;
}
QRect childRect = IconDelegate::getChildArrowRect(containingRect);
if(childRect.contains(pos)){
listWidgetItem->setSelected(true);
setCurrentRow(index.row());
CatItem clickItem(addPrefix(OPERATION_PREFIX,GOTO_CHILD_OPERATION));
gMainWidget->operateOnItem(path,clickItem);
return;
}
QRect depRect = IconDelegate::getDepricateItemRect(containingRect);
if(depRect.contains(localPos)){
CatItem depricateItem(addPrefix(OPERATION_PREFIX,DEPRICATE_OPERATION_NAME));
//emit listItemAction(path, depricateItem);
//fickin signals not going through...
gMainWidget->operateOnItem(path,depricateItem);
return;
}
if(listWidgetItem){
listWidgetItem->setSelected(true);
setCurrentRow(index.row());
CatItem clickItem(addPrefix(OPERATION_PREFIX,SELECTION_OPERATION_NAME));
gMainWidget->operateOnItem(path,clickItem);
}
}
void ItemsViewDelegate::updateItemWidgets(const QList<QWidget *> widgets,
const QStyleOptionViewItem &option,
const QPersistentModelIndex &index) const
{
const KNSCore::ItemsModel *model = qobject_cast<const KNSCore::ItemsModel *>(index.model());
if (!model) {
qCDebug(KNEWSTUFF) << "WARNING - INVALID MODEL!";
return;
}
KNSCore::EntryInternal entry = index.data(Qt::UserRole).value<KNSCore::EntryInternal>();
// setup the install button
int margin = option.fontMetrics.height() / 2;
int right = option.rect.width();
QToolButton *installButton = qobject_cast<QToolButton *>(widgets.at(DelegateInstallButton));
if (installButton != 0) {
if (installButton->menu()) {
QMenu *buttonMenu = installButton->menu();
buttonMenu->clear();
installButton->setMenu(0);
buttonMenu->deleteLater();
}
bool installable = false;
bool enabled = true;
QString text;
QIcon icon;
switch (entry.status()) {
case Entry::Installed:
text = i18n("Uninstall");
icon = m_iconDelete;
break;
case Entry::Updateable:
text = i18n("Update");
icon = m_iconUpdate;
installable = true;
break;
case Entry::Installing:
text = i18n("Installing");
enabled = false;
icon = m_iconUpdate;
break;
case Entry::Updating:
text = i18n("Updating");
enabled = false;
icon = m_iconUpdate;
break;
case Entry::Downloadable:
text = i18n("Install");
icon = m_iconInstall;
installable = true;
break;
case Entry::Deleted:
text = i18n("Install Again");
icon = m_iconInstall;
installable = true;
break;
default:
text = i18n("Install");
}
installButton->setText(text);
installButton->setEnabled(enabled);
installButton->setIcon(icon);
if (installable && entry.downloadLinkCount() > 1) {
QMenu *installMenu = new QMenu(installButton);
foreach (const KNSCore::EntryInternal::DownloadLinkInformation &info, entry.downloadLinkInformationList()) {
QString text = info.name;
if (!info.distributionType.trimmed().isEmpty()) {
text + " (" + info.distributionType.trimmed() + ')';
}
QAction *installAction = installMenu->addAction(m_iconInstall, text);
installAction->setData(QPoint(index.row(), info.id));
}
installButton->setMenu(installMenu);
}
}
