qgsgrassmodel.cpp

一个非常好的GIS开源新版本

QgsGrassModel::QgsGrassModel ( QObject * parent )
             : QAbstractItemModel ( parent  )
{
  QgsDebugMsg("called.");

  // Icons
  QStyle *style = QApplication::style();
  mIconDirectory = QIcon(style->standardPixmap(QStyle::SP_DirClosedIcon));
  mIconDirectory.addPixmap(style->standardPixmap(QStyle::SP_DirOpenIcon), 
    QIcon::Normal, QIcon::On);
  QString location = QgsGrass::getDefaultGisdbase() 
    + "/" + QgsGrass::getDefaultLocation();

  mIconFile = QIcon(style->standardPixmap(QStyle::SP_FileIcon));

  QString iconPath = QgsApplication::themePath();
  mIconPointLayer = QIcon ( iconPath+"/mIconPointLayer.png" );
  mIconLineLayer = QIcon ( iconPath+"/mIconLineLayer.png" );
  mIconPolygonLayer = QIcon ( iconPath+"/mIconPolygonLayer.png" );
  mIconVectorLayer = QIcon ( iconPath+"/grass/grass_browser_vector_layer.png" );
  mIconRasterLayer = QIcon ( iconPath+"/grass/grass_browser_raster_layer.png" );

  mRoot = new QgsGrassModelItem();
  mRoot->mType = QgsGrassModel::Location;
  mRoot->mModel = this;
  mRoot->mGisbase = QgsGrass::getDefaultGisdbase();
  mRoot->mLocation = QgsGrass::getDefaultLocation();
  //mRoot->refresh(); 
  refreshItem(mRoot);
}

QgsGrassModel::~QgsGrassModel() { }

void QgsGrassModel::refresh() 
{
  QgsDebugMsg("called.");

  //mRoot->refresh(); 
  refreshItem(mRoot); 
}

QModelIndex QgsGrassModel::index(QgsGrassModelItem *item)
{
  // Item index 
  QModelIndex index;
  if ( item->mParent ) {
    Q_ASSERT ( item->mParent->mChildren.size() > 0 );
    //QVector<QgsGrassModelItem> children = item->mParent->mChildren;
    //int row = (item - &(item->mParent->mChildren.at(0)));
    int row = -1;
    for ( int i = 0; i < item->mParent->mChildren.size(); i++ )
    {
      if ( item == item->mParent->mChildren[i] )
      {
        row = i;
        break;
      }
    } 
    Q_ASSERT ( row>=0 );    
    index = createIndex( row, 0, item );
  } else {
    index = QModelIndex();
  }
  return index;
}

void QgsGrassModel::removeItems(QgsGrassModelItem *item, QStringList list)
{
  QModelIndex index = QgsGrassModel::index ( item );
  // Remove items not present in the list
  for (int i = 0; i < item->mChildren.size();) 
  {
    if ( !list.contains(item->mChildren[i]->name()) )
    {
      QgsDebugMsg( QString("remove %1").arg( item->mChildren[i]->name() ) );
      beginRemoveRows( index, i, i );
      delete item->mChildren[i];
      item->mChildren.remove(i);
      endRemoveRows();
    }
    else
    {
      i++;
    } 
  }
}

void QgsGrassModel::addItems(QgsGrassModelItem *item, QStringList list, int type)
{
  //std::cerr << "QgsGrassModel::addItems" << std::endl;
  QModelIndex index = QgsGrassModel::index ( item );

  // Add new items

  for (int i = 0; i < list.size();i++) 
  {
    QString name = list.at(i);
    //std::cerr << "? add " << name.ascii() << std::endl;

    int insertAt = item->mChildren.size();
    for (int i = 0; i < item->mChildren.size();i++) 
    {
      if ( item->mChildren[i]->name() == name ) 
      {
        insertAt = -1;
        break;
      }
      if ( QString::localeAwareCompare(item->mChildren[i]->name(),name) > 0 )
      {
        insertAt = i;
        break;
      }
    }

    if ( insertAt >= 0 )
    {
      QgsDebugMsg( QString("insert %1 at %2").arg(name).arg(insertAt) );;
      beginInsertRows( index, insertAt, insertAt );
      QgsGrassModelItem *newItem = new QgsGrassModelItem();
      item->mChildren.insert( insertAt, newItem );
      //QgsGrassModelItem *newItem = &(item->mChildren[insertAt]);
      newItem->mType = type;
      newItem->mParent = item;
      newItem->copyNames(item);
      switch ( newItem->mType ) 
      {
      case QgsGrassModel::Location:
        newItem->mLocation = name;
        break;
      case QgsGrassModel::Mapset:
        newItem->mMapset = name;
        break;
      case QgsGrassModel::Vectors:
      case QgsGrassModel::Rasters:
      case QgsGrassModel::Regions:
        break;
      case QgsGrassModel::Vector:
      case QgsGrassModel::Raster:
      case QgsGrassModel::Region:
        newItem->mMap = name;
        break;
      case QgsGrassModel::VectorLayer:
        newItem->mLayer = name;
        break;
      }

      endInsertRows();
    }
  }
}

void QgsGrassModel::refreshItem(QgsGrassModelItem *item)
{
  QgsDebugMsg( QString("called with item type %1").arg(item->mType) );

  // to avoid and endless recusion with Qt 4.4 let's pretend we already have populated 
  item->mPopulated = true;

  switch ( item->mType ) 
  {
  case QgsGrassModel::Location:
    {
      QStringList list = QgsGrass::mapsets ( item->mGisbase, item->mLocation );
      removeItems(item, list);
      addItems(item, list, QgsGrassModel::Mapset );
    }
    break;

  case QgsGrassModel::Mapset:
    {
      QStringList vectors = QgsGrass::vectors ( item->mGisbase, 
        item->mLocation, item->mMapset );
      QStringList rasters = QgsGrass::rasters ( item->mGisbase, 
        item->mLocation, item->mMapset );
      QStringList regions = QgsGrass::elements ( item->mGisbase, 
        item->mLocation, item->mMapset,
        "windows" );

      QStringList list;
      if ( vectors.count() > 0 ) list.append("vector");
      if ( rasters.count() > 0 ) list.append("raster");
      if ( regions.count() > 0 ) list.append("region");

      removeItems(item, list);

      if ( vectors.count() > 0 )
        addItems(item, QStringList("vector"), QgsGrassModel::Vectors );

      if ( rasters.count() > 0 )
        addItems(item, QStringList("raster"), QgsGrassModel::Rasters );

      if ( regions.count() > 0 )
        addItems(item, QStringList("region"), QgsGrassModel::Regions );

    }
    break;

  case QgsGrassModel::Vectors:
  case QgsGrassModel::Rasters:
  case QgsGrassModel::Regions:
    {
      QStringList list;
      int type = 0; 
      if ( item->mType == QgsGrassModel::Vectors )
      {
        list = QgsGrass::vectors ( item->mGisbase, item->mLocation, 
          item->mMapset );
        type = QgsGrassModel::Vector;
      }
      else if ( item->mType == QgsGrassModel::Rasters )
      {
        list = QgsGrass::rasters ( item->mGisbase, item->mLocation, 
          item->mMapset );
        type = QgsGrassModel::Raster;
      }
      else if ( item->mType == QgsGrassModel::Regions )
      {
        list = QgsGrass::elements ( item->mGisbase, item->mLocation, 
          item->mMapset, "windows" );
        type = QgsGrassModel::Region;
      }

      removeItems(item, list);
      addItems(item, list, type );

    }
    break;

  case QgsGrassModel::Vector:
    {
      QStringList list = QgsGrassSelect::vectorLayers ( 
        QgsGrass::getDefaultGisdbase(), 
        QgsGrass::getDefaultLocation(),
        item->mMapset, item->mMap );

      removeItems(item, list);
      addItems(item, list, QgsGrassModel::VectorLayer );
    }
    break;

  case QgsGrassModel::Raster:
    break;

  case QgsGrassModel::Region:
    break;

  case QgsGrassModel::VectorLayer:
    break;
  }
  for ( int i = 0; i < item->mChildren.size(); i++ )
  {
    if ( item->mChildren[i]->mPopulated ) {
      refreshItem( item->mChildren[i] );
    }
  }
}

QModelIndex QgsGrassModel::index( int row, int column, 
	                        const QModelIndex & parent ) const
{
  //std::cerr << "QgsGrassModel::index row = " << row 
  //                      << " column = " << column << std::endl;

  // It is strange(?) but Qt can call this method with row < 0
  // for example if beginInsertRows(,0,0) is called and the first
  // item was previously deleted => check if row < 0
  // and return empty QModelIndex, but is it correct?
  if ( row < 0 ) return QModelIndex ();    

  QgsGrassModelItem *item;
  if (!parent.isValid()) { 
    item = mRoot; 
  } else { 
    item = static_cast<QgsGrassModelItem*>(parent.internalPointer());
  }
  //if ( !item->populated() ) refreshItem(item);
  if ( !item->populated() ) item->populate();
  return createIndex ( row, column, item->child(row) );
}

QModelIndex QgsGrassModel::parent ( const QModelIndex & index ) const
{
  //std::cerr << "QgsGrassModel::parent" << std::endl;

  if (!index.isValid()) return QModelIndex();

  QgsGrassModelItem *item =
    static_cast<QgsGrassModelItem*>(index.internalPointer());

  QgsGrassModelItem *parentNode = item->mParent;

  if ( parentNode == 0 || parentNode == mRoot) return QModelIndex();

  // parent's row
  QVector<QgsGrassModelItem*> children = parentNode->mParent ? 
    parentNode->mParent->mChildren : mRoot->mChildren;
  int row = -1;
  for ( int i = 0; i < children.size(); i++ )
  {
    if ( parentNode == children[i] )
    {
      row = i;
      break;
    }
  } 
  Q_ASSERT ( row>=0 );    
  return createIndex(row, 0, parentNode);
}

int QgsGrassModel::rowCount ( const QModelIndex & parent ) const
{
  //std::cerr << "QgsGrassModel::rowCount" << std::endl;
  QgsGrassModelItem *item;
  if (!parent.isValid()) { 
    item = mRoot; 
  } else { 
    item = static_cast<QgsGrassModelItem*>(parent.internalPointer());
  }
  //std::cerr << "name = " << item->name().ascii() << std::endl;
  //std::cerr << "count = " << item->mChildren.size() << std::endl;
  if ( !item->populated() ) item->populate();
  //if ( !item->populated() ) refreshItem(item);
  return item->mChildren.size();
}

int QgsGrassModel::columnCount ( const QModelIndex & parent ) const
{
  //std::cerr << "QgsGrassModel::columnCount" << std::endl;
  return 1;
}

QVariant QgsGrassModel::data ( const QModelIndex &index, int role ) const 
{
  //std::cerr << "QgsGrassModel::data" << std::endl;

  if (!index.isValid()) { return QVariant(); } 
  if (role != Qt::DisplayRole && role != Qt::DecorationRole) return QVariant();

  QgsGrassModelItem *item;
  item = static_cast<QgsGrassModelItem*>(index.internalPointer());

  if ( role == Qt::DecorationRole ) 
  {
    switch ( item->type() )
    {
    case QgsGrassModel::Vector :
      return mIconVectorLayer;
      break;

    case QgsGrassModel::Raster :
      return mIconRasterLayer;
      break;

    case QgsGrassModel::Region :
      return mIconFile;
      break;

    case QgsGrassModel::VectorLayer :
      if ( item->mLayer.contains("point") )
      {
        return mIconPointLayer;
      } 
      else if ( item->mLayer.contains("line") )
      {
        return mIconLineLayer;
      }
      else if ( item->mLayer.contains("polygon") )
      {
        return mIconPolygonLayer;
      }
      else
      {
        return mIconFile; 
      }
      break;

    default:
      return mIconDirectory; 
    }
    return mIconDirectory;
  }
  return item->data(role);
}

QString QgsGrassModel::itemName ( const QModelIndex &index)
{
  if (!index.isValid()) { return QString(); } 

  QgsGrassModelItem *item;
  item = static_cast<QgsGrassModelItem*>(index.internalPointer());

  return item->name();
}

QString QgsGrassModel::itemMapset ( const QModelIndex &index)
{
  if (!index.isValid()) { return QString(); } 

  QgsGrassModelItem *item;
  item = static_cast<QgsGrassModelItem*>(index.internalPointer());

  return item->mMapset;
}

QString QgsGrassModel::itemMap ( const QModelIndex &index)
{
  if (!index.isValid()) { return QString(); } 

  QgsGrassModelItem *item;
  item = static_cast<QgsGrassModelItem*>(index.internalPointer());

  return item->mMap;
}

QString QgsGrassModel::itemInfo ( const QModelIndex &index)
{
  if (!index.isValid()) { return QString(); } 

  QgsGrassModelItem *item;
  item = static_cast<QgsGrassModelItem*>(index.internalPointer());

  return item->info();
}

int QgsGrassModel::itemType ( const QModelIndex &index ) const 
{
  if (!index.isValid()) { return QgsGrassModel::None; } 
  QgsGrassModelItem *item;
  item = static_cast<QgsGrassModelItem*>(index.internalPointer());
  return item->type();
}

QString QgsGrassModel::uri ( const QModelIndex &index ) const 
{
  if (!index.isValid()) { return QString(); } 
  QgsGrassModelItem *item;
  item = static_cast<QgsGrassModelItem*>(index.internalPointer());
  return item->uri();
}

void QgsGrassModel::setLocation( const QString &gisbase, const QString &location ) 
{ 
  removeItems(mRoot, QStringList());
  mGisbase = gisbase;
  mLocation = location;
  mRoot->mGisbase = gisbase;
  mRoot->mLocation = location;
  refreshItem(mRoot);
}

QVariant QgsGrassModel::headerData( int section, 
                                    Qt::Orientation orientation, int role) const
{
  //std::cerr << "QgsGrassModel::headerData" << std::endl;

  //TODO
  //if (orientation == Qt::Horizontal && role == Qt::DisplayRole)

  return QVariant();
}

Qt::ItemFlags QgsGrassModel::flags(const QModelIndex &index) const
{
  //std::cerr << "QgsGrassModel::flags" << std::endl;

  //TODO
  if (!index.isValid())
    return Qt::ItemIsEnabled;

  return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}