QModelIndex CharacteristicsModel::index(int row, int column,
                  const QModelIndex &parent) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    CharacteristicsItem *parentItem;

    if (!parent.isValid())
        parentItem = _root;
    else
        parentItem = static_cast<CharacteristicsItem*>(parent.internalPointer());

    CharacteristicsItem *childItem = parentItem->child(row);
    if (childItem)
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}
Example #2
0
 QModelIndex DemandScenarioTreeModel::index(int row, int column, const QModelIndex &parent)
             const
 {
     if (!hasIndex(row, column, parent))
         return QModelIndex();

     DemandTreeItem *parentItem;

     if (!parent.isValid())
         parentItem = rootItem;
     else
         parentItem = static_cast<DemandTreeItem*>(parent.internalPointer());

     DemandTreeItem *childItem = parentItem->child(row);
     if (childItem)
         return createIndex(row, column, childItem);
     else
         return QModelIndex();
 }
QModelIndex FavoriteUsersModel::index(int row, int column, const QModelIndex &parent)
            const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    FavoriteUserItem *parentItem;

    if (!parent.isValid())
        parentItem = rootItem;
    else
        parentItem = static_cast<FavoriteUserItem*>(parent.internalPointer());

    FavoriteUserItem *childItem = parentItem->child(row);
    if (childItem)
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}
Example #4
0
QModelIndex QgsReportSectionModel::index( int row, int column, const QModelIndex &parent ) const
{
  if ( !hasIndex( row, column, parent ) )
    return QModelIndex();

  QgsAbstractReportSection *parentSection = sectionForIndex( parent );
  if ( parentSection )
  {
    QgsAbstractReportSection *item = parentSection->childSections().value( row, nullptr );
    return item ? createIndex( row, column, item ) : QModelIndex();
  }
  else
  {
    if ( row == 0 )
      return createIndex( row, column, nullptr );
    else
      return QModelIndex();
  }
}
 QModelIndex LapInformationTreeModel::index(int row, int column,
                                            const QModelIndex& parent) const
 {
     /*
     if (parent.isValid() && parent.column() != 0)
         return QModelIndex();
     */
     if (!hasIndex(row, column, parent))
         return QModelIndex();

     TreeElement *parentItem = this->nodeFromIndex(parent);

     TreeElement *childItem = parentItem->child(row); // peut être NULL

     if (childItem)
         return this->createIndex(row, column, childItem); // Méthode de QAbstractItemModel
     else
         return QModelIndex();
 }
/**
 * @brief ProjectManagerTreeModel::index Get index of item on row and column with given parent.
 * @param row Row number.
 * @param column Column number.
 * @param parent Parent of item we want to get.
 * @return Index of our item.
 */
QModelIndex ProjectManagerTreeModel::index(int row, int column, const QModelIndex &parent) const
{
    if(!hasIndex(row, column, parent))
        return QModelIndex();

    ProjectTreeItem* pItem;

    if(!parent.isValid())
        pItem = root;
    else
        pItem = static_cast<ProjectTreeItem*>(parent.internalPointer());

    ProjectTreeItem* cItem = pItem->getChild(row);

    if(cItem)
        return createIndex(row,column, cItem);
    else
        return QModelIndex();
}
QModelIndex Model::index(int row, int column, const QModelIndex &parent) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    Node *parentNode;

    if (!parent.isValid())
        parentNode = manager->getRootNode();
    else
        parentNode = static_cast<Node *>(parent.internalPointer());

    if (row >= 0 && row < parentNode->getChildren().size()) {
        Node *childNode = parentNode->getChildren().value(row);
        return createIndex(row, column, childNode);
    }

    return QModelIndex();
}
Example #8
0
QModelIndex Entities::index(int row, int column, const QModelIndex &parent)
        const
{
    if(!hasIndex(row, column, parent))
        return QModelIndex();

    EntitiesTreeItem *parentEntitiesTreeItem;

    if(!parent.isValid())
        parentEntitiesTreeItem = rootEntitiesTreeItem;
    else
        parentEntitiesTreeItem = static_cast<EntitiesTreeItem*>(parent.internalPointer());

    EntitiesTreeItem *childEntitiesTreeItem = parentEntitiesTreeItem->child(row);
    if(childEntitiesTreeItem)
        return createIndex(row, column, childEntitiesTreeItem);
    else
        return QModelIndex();
}
QModelIndex
SupportedLocalesModel::index( int row, int column, const QModelIndex& parent ) const
{
    if ( !hasIndex( row, column, parent ) )
        return QModelIndex();

    SupportedLocalesItem* parentItem;

    if ( !parent.isValid() )
        parentItem = m_rootItem;
    else
        parentItem = static_cast<SupportedLocalesItem*>( parent.internalPointer() );

    SupportedLocalesItem* childItem = parentItem->child( row );
    if ( childItem )
        return createIndex( row, column, childItem );
    else
        return QModelIndex();
}
Example #10
0
void LuaInterface::clearTable(int index)
{
    assert(hasIndex(index) && isTable(index));
    pushNil(); // table, nil
    bool stop = false;
    while(next(index-1)) { // table, key, value
        pop(); // table, key
        pushValue(); // table, key, key
        if(next(index-2)) { // table, key, nextkey, value
            pop(); // table, key, nextkey
            insert(-2); // table, nextkey, key
            pushNil(); // table, nextkey, key, nil
            rawSet(index-3); // table, nextkey
        } else { // table, key
            pushNil(); // table, key, nil
            rawSet(index-2); // table
            break;
        }
    }
}
Example #11
0
QModelIndex TagMngrListModel::index(int row, int column, const QModelIndex& parent)
            const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    ListItem* parentItem = 0;

    if (!parent.isValid())
        parentItem = d->rootItem;
    else
        parentItem = static_cast<ListItem*>(parent.internalPointer());

    ListItem* const childItem = parentItem->child(row);

    if (childItem)
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}
Example #12
0
QModelIndex PublicHubModel::index(int row, int column, const QModelIndex &parent)
            const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    PublicHubItem *parentItem;

    if (!parent.isValid())
        parentItem = rootItem;
    else
        parentItem = static_cast<PublicHubItem*>(parent.internalPointer());

    PublicHubItem *childItem = parentItem->child(row);

    if (childItem && rootItem->childItems.contains(childItem))
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}
QModelIndex SnapshotTreeModel::index(int row, int column, const QModelIndex &parent) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    TreeItem *parentItem;

    if (!parent.isValid()) {
        parentItem = rootItem;
    } else {
        parentItem = static_cast<TreeItem*>(parent.internalPointer());
        if ( parentItem==Q_NULLPTR ) parentItem = rootItem;
    };

    TreeItem *childItem = parentItem->child(row);
    if (childItem)
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}
Example #14
0
    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override
    {
        if (hasIndex(index.row(), index.column(), index.parent())) {
            const Item &item(m_items[index.row()]);

            switch (role) {
            // Return a pixmap so the view will draw it at the given size instead of the view icon size
            case Qt::DecorationRole:
                return item.pixmap;
            case Qt::ForegroundRole:
                return item.pen.brush();
            case Qt::DisplayRole:
                return LegendModel::tr(item.label.constData());
            case Qt::SizeHintRole:
                return QSize(-1, (item.pixmap.height() / item.pixmap.devicePixelRatio()) + (2 * 2));
            }
        }

        return QVariant();
    }
Example #15
0
QModelIndex MenuModel::index( int row, int column, const QModelIndex &parent ) const
{
    if ( !hasIndex(row, column, parent) ) {
        return QModelIndex();
    }

    MenuItem *parentItem;
    if ( !parent.isValid() ) {
        parentItem = d->rootItem;
    } else {
        parentItem = static_cast<MenuItem*>( parent.internalPointer() );
    }

    MenuItem *childItem = childrenList(parentItem).value(row);
    if ( childItem ) {
        return createIndex( row, column, childItem );
    } else {
        return QModelIndex();
    }
}
QModelIndex ScriptEngineModel::index(int row, int column, const QModelIndex& parent) const
{
    if (!m_rootNode)
        return QModelIndex();

    if (!hasIndex(row,column,parent))
        return QModelIndex();

    ScriptEngineNode* parentNode;
    if (parent.isValid()){
        parentNode = nodeFromIndex(parent);
    } else {
        parentNode = m_rootNode;
    }

    ScriptEngineNode* childNode = parentNode->child(row);
    if (childNode){
        return createIndex(row,column,childNode);
    } else return QModelIndex();
}
Example #17
0
QModelIndex ananasListViewModel::index(int row, int column, const QModelIndex &parent)
            const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    DomCfgItem *parentItem;

    if (!parent.isValid()) 
        parentItem = rootItem;
    else
        parentItem = static_cast<DomCfgItem*>(parent.internalPointer());

    DomCfgItem *childItem = parentItem->child(row);

    if (childItem)
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}
QModelIndex SimpleFSModel::index(int row, int column,
     const QModelIndex& parent) const
{
    if (!hasIndex(row, column, parent))
    {
        return QModelIndex();
    }

    if (!parent.isValid()) // запрашивают индексы корневых узлов
    {
        Q_ASSERT(nodes_.size() > row);
        return createIndex(row, column, const_cast<NodeInfo*>(&nodes_[row]));
    }

    NodeInfo* parentInfo = static_cast<NodeInfo*>(parent.internalPointer());
    Q_ASSERT(parentInfo != 0);
    Q_ASSERT(parentInfo->mapped);
    Q_ASSERT(parentInfo->children.size() > row);
    return createIndex(row, column, &parentInfo->children[row]);
}
Example #19
0
QModelIndex LocalsTreeModel::index(int row, int column, const QModelIndex &parent) const
{
  if (!hasIndex(row, column, parent)) {
    return QModelIndex();
  }

  LocalsTreeItem *pParentLocalsTreeViewItem;
  if (!parent.isValid()) {
    pParentLocalsTreeViewItem = mpRootLocalsTreeItem;
  } else {
    pParentLocalsTreeViewItem = static_cast<LocalsTreeItem*>(parent.internalPointer());
  }

  LocalsTreeItem *pChildLocalsTreeViewItem = pParentLocalsTreeViewItem->child(row);
  if (pChildLocalsTreeViewItem) {
    return createIndex(row, column, pChildLocalsTreeViewItem);
  } else {
    return QModelIndex();
  }
}
Example #20
0
/*! Возвращает модельный индекс по заданным значениям row, column и parent. */
QModelIndex QstTreeQueryModel::index(int row, int column, const QModelIndex& parent) const
{
		Q_ASSERT(_root != NULL);

	if (!hasIndex(row, column, parent))
		return QModelIndex();

	QstTreeItem *parentItem;

	if (!parent.isValid())
		parentItem = _root;
	else
		parentItem = static_cast<QstTreeItem*>(parent.internalPointer());

	QstTreeItem *childItem = parentItem->child(row);
	if (childItem)
		return createIndex(row, column, childItem);
	else
		return QModelIndex();
}
 QModelIndex CQTOpenGLLuaStateTreeModel::index(int n_row,
                                               int n_column,
                                               const QModelIndex& c_parent) const {
    if(!hasIndex(n_row, n_column, c_parent)) {
       return QModelIndex();
    }
    CQTOpenGLLuaStateTreeItem* pcParentItem;
    if(!c_parent.isValid()) {
       pcParentItem = m_pcDataRoot;
    }
    else {
       pcParentItem = static_cast<CQTOpenGLLuaStateTreeItem*>(c_parent.internalPointer());
    }
    CQTOpenGLLuaStateTreeItem* pcChildItem = pcParentItem->GetChild(n_row);
    if(pcChildItem) {
       return createIndex(n_row, n_column, pcChildItem);
    }
    else {
       return QModelIndex();
    }
 }
Example #22
0
QModelIndex DirectoryModel::index(int row, int column,
                  const QModelIndex &parent /*= QModelIndex()*/) const
{
    if (!hasIndex(row, column, parent))
            return QModelIndex();

    DirNode* parentItem;

    if (!parent.isValid())
        parentItem = m_rootItem;
    else
        parentItem = static_cast<DirNode*>(parent.internalPointer());

    Q_ASSERT(row < parentItem->m_dir_vector.size());
    DirNode *childItem = parentItem->m_dir_vector.at(row);

    if (childItem)
        return createIndex(row, column, childItem);
    else
        return QModelIndex();
}
Example #23
0
QModelIndex MetadataTreeModel::index(int row, int column, const QModelIndex &parent) const
{
	if (!hasIndex(row, column, parent)) {
		return QModelIndex();
	}

	MetadataTreeItem *parentItem;

	if (!parent.isValid()) {
		parentItem = m_rootItem;
	} else {
		parentItem = static_cast<MetadataTreeItem*>(parent.internalPointer());
	}

	MetadataTreeItem *childItem = parentItem->child(row);
	if (childItem) {
		return createIndex(row, column, childItem);
	}

	return QModelIndex();
}
Example #24
0
QModelIndex MusicLibraryModel::index(int row, int column, const QModelIndex &parent) const
{
    if (!hasIndex(row, column, parent)) {
        return QModelIndex();
    }

    const MusicLibraryItem * parentItem;

    if (!parent.isValid()) {
        parentItem = rootItem;
    } else {
        parentItem = static_cast<MusicLibraryItem *>(parent.internalPointer());
    }

    MusicLibraryItem * const childItem = parentItem->childItem(row);
    if (childItem) {
        return createIndex(row, column, childItem);
    }

    return QModelIndex();
}
Example #25
0
QModelIndex InventoryItemModel::index(int row, int column, const QModelIndex &parent) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

    ///\todo Use AbstractInventoryItem?
    InventoryFolder *parentItem = 0;

    if (!parent.isValid())
        parentItem = static_cast<InventoryFolder *>(dataModel_->GetRoot());
    else
        parentItem = static_cast<InventoryFolder *>(reinterpret_cast<AbstractInventoryItem *>(parent.internalPointer()));

    AbstractInventoryItem *childItem = parentItem->Child(row);
    if (childItem)
        return createIndex(row, column, reinterpret_cast<void *>(childItem));
    else
        return QModelIndex();

    return QModelIndex();
}
Example #26
0
QModelIndex FilmsListModel::index( int row, int column, const QModelIndex& parent ) const
{
    if( hasIndex( row, column, parent ) )
    {
        FilmItem* parentItem = rootItem;

        if( parent.isValid() )
        {
            parentItem = static_cast<FilmItem*>( parent.internalPointer() );
        }

        FilmItem* childItem = parentItem->GetChild( row );

        if( childItem != nullptr )
        {
            return( createIndex( row, column, childItem ) );
        }
    }

    return( QModelIndex() );
}
Example #27
0
QModelIndex ChapterModel::index(int row, int column,
                                const QModelIndex& parent) const
{
  if( !hasIndex(row, column, parent) ) {
    return QModelIndex();
  }

  csAbstractTreeItem *parentItem(0);
  if( !parent.isValid() ) {
    parentItem = _root;
  } else {
    parentItem = priv::treeItem(parent);
  }

  csAbstractTreeItem *childItem = parentItem->childItem(row);
  if( childItem != 0 ) {
    return createIndex(row, column, childItem);
  }

  return QModelIndex();
}
QModelIndex VibesTreeModel::index(int row, int column, const QModelIndex &parent) const
{
    if (!hasIndex(row, column, parent))
        return QModelIndex();

 /*   const void *parentItem;

    if (!parent.isValid())
        parentItem = figures;
    else
        parentItem = parent.internalPointer();

    if (!parentItem)
        return QModelIndex();

    if (parentItem == figures)
    {
        if (row < figures->size())
            return createIndex(row, column, figures->values().at(row));
        else
            return QModelIndex();
    }*/

    if (!parent.isValid())
    {
        if (row < figures->size())
            return createIndex(row, column, (void*)0);
        else
            return QModelIndex();
    }

    if (parent.internalPointer() == 0)
    {
        return createIndex(row, column, figures->values().at(parent.row()));
    }



    return QModelIndex();
}
Example #29
0
QVariant
JobStatusModel::data( const QModelIndex& index, int role ) const
{
    if ( !hasIndex( index.row(), index.column(), index.parent() ) )
        return QVariant();

    JobStatusItem* item = m_items[ index.row() ];

    switch ( role )
    {
        case Qt::DecorationRole:
            return item->icon();
            
        case Qt::ToolTipRole:
            
        case Qt::DisplayRole:
        {
            if ( m_collapseCount.contains( item->type() ) )
                return m_collapseCount[ item->type() ].last()->mainText();
            else
                return item->mainText();
        }
        
        case RightColumnRole:
        {
            if ( m_collapseCount.contains( item->type() ) )
                return m_collapseCount[ item->type() ].count();
            else
                return item->rightColumnText();
        }
        
        case AllowMultiLineRole:
            return item->allowMultiLine();

        case JobDataRole:
            return QVariant::fromValue< JobStatusItem* >( item );
    }

    return QVariant();
}
Example #30
0
MovingPath MovingPathScript::MovingPathScriptImpl::createPath(const MovingPath & oldPath, const GridIndex & destination, const MovingArea & area) const
{
	auto newPath = oldPath;

	//Init the path if it's empty.
	if (newPath.isEmpty()) {
		auto startingIndex = area.getStartingIndex();
		auto startingInfo = area.getMovingInfo(startingIndex);
		newPath.init(MovingPath::PathNode(startingIndex, startingInfo.m_MaxRemainingMovementRange));
	}

	//If the destination is in the path already, cut the path and return.
	if (newPath.hasIndex(destination)) {
		newPath.tryFindAndCut(destination);
		return newPath;
	}

	//The destination is not in the path. Try extending the path to destination. Return the new path if succeed.
	if (newPath.tryExtend(destination, area.getMovingInfo(destination).m_MovingCost))
		return newPath;

	//The path can't be extended (because the remaining movement range is not big enough).
	//Generate a new shortest path.
	auto pathNodeList = std::list<MovingPath::PathNode>();
	auto currentIndex = destination;
	auto currentInfo = area.getMovingInfo(currentIndex);
	auto previousIndex = currentInfo.m_PreviousIndex;
	auto startingIndex = area.getStartingIndex();

	while (currentIndex != startingIndex) {
		pathNodeList.emplace_front(MovingPath::PathNode(currentIndex, currentInfo.m_MaxRemainingMovementRange));
		currentIndex = previousIndex;
		currentInfo = area.getMovingInfo(currentIndex);
		previousIndex = currentInfo.m_PreviousIndex;
	}
	pathNodeList.emplace_front(MovingPath::PathNode(startingIndex, area.getMovingInfo(startingIndex).m_MaxRemainingMovementRange));

	newPath.init(std::move(pathNodeList));
	return newPath;
}