[GRASS] temporal modules input

blazek · blazek · commit 6bd96b28109c · 2015-10-18T12:58:09.000+02:00
diff --git a/src/plugins/grass/qgsgrassmoduleinput.cpp b/src/plugins/grass/qgsgrassmoduleinput.cpp
@@ -64,6 +64,7 @@ QgsGrassModuleInputModel::QgsGrassModuleInputModel( QObject *parent )
 
   mWatcher = new QFileSystemWatcher( this );
   connect( mWatcher, SIGNAL( directoryChanged( const QString & ) ), SLOT( onDirectoryChanged( const QString & ) ) );
+  connect( mWatcher, SIGNAL( fileChanged( const QString & ) ), SLOT( onFileChanged( const QString & ) ) );
 
   connect( QgsGrass::instance(), SIGNAL( mapsetChanged() ), SLOT( onMapsetChanged() ) );
 
@@ -80,7 +81,7 @@ void QgsGrassModuleInputModel::onDirectoryChanged( const QString & path )
   QDir parentDir( path );
   parentDir.cdUp();
   QString mapset;
-
+  QList<QgsGrassObject::Type> types;
   if ( path == locationPath )
   {
     QgsDebugMsg( "location = " + path );
@@ -117,25 +118,58 @@ void QgsGrassModuleInputModel::onDirectoryChanged( const QString & path )
     {
       watch( path + "/" + watchedDir );
     }
+    // TODO: use db path defined in mapset VAR
+    watch( path + "/tgis/sqlite.db" );
   }
   else // cellhd or vector dir
   {
     QgsDebugMsg( "cellhd/vector = " + path );
     mapset = parentDir.dirName();
+    if ( path.endsWith( "cellhd" ) )
+    {
+      types << QgsGrassObject::Raster;
+    }
+    else if ( path.endsWith( "vector" ) )
+    {
+      types << QgsGrassObject::Vector;
+    }
   }
   if ( !mapset.isEmpty() )
   {
     QList<QStandardItem *> items = findItems( mapset );
     if ( items.size() == 1 )
     {
-      refreshMapset( items[0], mapset );
+      refreshMapset( items[0], mapset, types );
+    }
+  }
+}
+
+void QgsGrassModuleInputModel::onFileChanged( const QString & path )
+{
+  QgsDebugMsg( "path = " + path );
+  // when tgis/sqlite.db is changed, this gets called twice, probably the file changes more times when it is modified
+  if ( path.endsWith( "/tgis/sqlite.db" ) )
+  {
+    QDir dir = QFileInfo( path ).dir();
+    dir.cdUp();
+    QString mapset = dir.dirName();
+    QList<QStandardItem *> items = findItems( mapset );
+    if ( items.size() == 1 )
+    {
+      QList<QgsGrassObject::Type> types;
+      types << QgsGrassObject::Strds << QgsGrassObject::Stvds << QgsGrassObject::Str3ds;
+      refreshMapset( items[0], mapset, types );
     }
   }
 }
 
 void QgsGrassModuleInputModel::watch( const QString & path )
 {
-  if ( !mWatcher->directories().contains( path ) && QFileInfo( path ).exists() )
+  if ( QFileInfo( path ).isDir() && !mWatcher->directories().contains( path ) )
+  {
+    mWatcher->addPath( path );
+  }
+  else if ( QFileInfo( path ).isFile() && !mWatcher->files().contains( path ) )
   {
     mWatcher->addPath( path );
   }
@@ -163,19 +197,24 @@ void QgsGrassModuleInputModel::addMapset( const QString & mapset )
   appendRow( mapsetItem );
 }
 
-void QgsGrassModuleInputModel::refreshMapset( QStandardItem *mapsetItem, const QString & mapset )
+void QgsGrassModuleInputModel::refreshMapset( QStandardItem *mapsetItem, const QString & mapset, const QList<QgsGrassObject::Type> & theTypes )
 {
   QgsDebugMsg( "mapset = " + mapset );
   if ( !mapsetItem )
   {
     return;
   }
 
-  QList<QgsGrassObject::Type> types;
-  types << QgsGrassObject::Raster << QgsGrassObject::Vector;
+  QList<QgsGrassObject::Type> types = theTypes;
+  if ( types.isEmpty() )
+  {
+    types << QgsGrassObject::Raster << QgsGrassObject::Vector;
+    types << QgsGrassObject::Strds << QgsGrassObject::Stvds << QgsGrassObject::Str3ds;
+  }
   foreach ( QgsGrassObject::Type type, types )
   {
-    QStringList maps = QgsGrass::grassObjects( QgsGrass::getDefaultGisdbase() + "/" + QgsGrass::getDefaultLocation() + "/" + mapset, type );
+    QgsGrassObject mapsetObject( QgsGrass::getDefaultGisdbase(), QgsGrass::getDefaultLocation(), mapset, "", QgsGrassObject::Mapset );
+    QStringList maps = QgsGrass::grassObjects( mapsetObject, type );
     QStringList mapNames;
     foreach ( const QString& map, maps )
     {
@@ -230,9 +269,16 @@ void QgsGrassModuleInputModel::refreshMapset( QStandardItem *mapsetItem, const Q
 
 void QgsGrassModuleInputModel::reload()
 {
+
   QgsDebugMsg( "entered" );
-  mWatcher->removePaths( mWatcher->files() );
-  mWatcher->removePaths( mWatcher->directories() );
+  if ( !mWatcher->files().isEmpty() )
+  {
+    mWatcher->removePaths( mWatcher->files() );
+  }
+  if ( !mWatcher->directories().isEmpty() )
+  {
+    mWatcher->removePaths( mWatcher->directories() );
+  }
 
   clear();
 
@@ -258,6 +304,7 @@ void QgsGrassModuleInputModel::reload()
     {
       watch( dirPath + "/" + watchedDir );
     }
+    watch( dirPath + "/tgis/sqlite.db" );
   }
 }
 
@@ -825,6 +872,18 @@ QgsGrassModuleInput::QgsGrassModuleInput( QgsGrassModule *module,
   {
     mType = QgsGrassObject::Raster;
   }
+  else if ( element == "strds" )
+  {
+    mType = QgsGrassObject::Strds;
+  }
+  else if ( element == "stvds" )
+  {
+    mType = QgsGrassObject::Stvds;
+  }
+  else if ( element == "str3ds" )
+  {
+    mType = QgsGrassObject::Str3ds;
+  }
   else
   {
     mErrors << tr( "GRASS element %1 not supported" ).arg( element );
diff --git a/src/plugins/grass/qgsgrassmoduleinput.h b/src/plugins/grass/qgsgrassmoduleinput.h
@@ -77,16 +77,17 @@ class QgsGrassModuleInputModel : public QStandardItemModel
     void onMapsetChanged();
 
     void onDirectoryChanged( const QString & path );
+    void onFileChanged( const QString & path );
     void onMapsetSearchPathChanged();
 
   private:
     void addMapset( const QString & mapset );
-    void refreshMapset( QStandardItem *mapsetItem, const QString & mapset );
+    void refreshMapset( QStandardItem *mapsetItem, const QString & mapset, const QList<QgsGrassObject::Type> & theTypes = QList<QgsGrassObject::Type>() );
     // Add to watched paths if exists and if not yet watched
     void watch( const QString & path );
     QString mLocationPath;
     // mapset watched dirs
-    QStringList watchedDirs() { QStringList l; l << "cellhd" << "vector"; return l; }
+    QStringList watchedDirs() { QStringList l; l << "cellhd" << "vector" << "tgis"; return l; }
     // names of
     QStringList locationDirNames();
     QFileSystemWatcher *mWatcher;
diff --git a/src/plugins/grass/qgsgrassmoduleoptions.cpp b/src/plugins/grass/qgsgrassmoduleoptions.cpp
@@ -201,7 +201,8 @@ QgsGrassModuleStandardOptions::QgsGrassModuleStandardOptions(
           QString element = promptElem.attribute( "element" );
           QString age = promptElem.attribute( "age" );
           //QgsDebugMsg("element = " + element + " age = " + age);
-          if ( age == "old" && ( element == "vector" || element == "cell" ) )
+          if ( age == "old" && ( element == "vector" || element == "cell" ||
+                                 element == "strds" || element == "stvds" || element == "str3ds" ) )
           {
             QgsGrassModuleInput *mi = new QgsGrassModuleInput(
               mModule, this, key, confDomElement, descDocElem, gnode, mDirect, this );
diff --git a/src/plugins/grass/qgsgrasstools.cpp b/src/plugins/grass/qgsgrasstools.cpp
@@ -128,7 +128,6 @@ class QgsGrassToolsTreeFilterProxyModel : public QSortFilterProxyModel
 
       for ( int i = 0; i < mModel->rowCount( sourceIndex ); i++ )
       {
-        QgsDebugMsg( QString( "i = %1" ).arg( i ) );
         QModelIndex sourceChildIndex = mModel->index( i, 0, sourceIndex );
         if ( filterAcceptsItem( sourceChildIndex ) )
           return true;
diff --git a/src/providers/grass/qgsgrass.cpp b/src/providers/grass/qgsgrass.cpp
@@ -165,22 +165,33 @@ bool QgsGrassObject::setFromUri( const QString& uri )
 
 QString QgsGrassObject::elementShort() const
 {
-  if ( mType == Raster )
+  return elementShort( mType );
+}
+
+QString QgsGrassObject::elementShort( Type type )
+{
+  if ( type == Raster )
 #if GRASS_VERSION_MAJOR < 7
     return "rast";
 #else
     return "raster";
 #endif
-  else if ( mType == Group )
+  else if ( type == Group )
     return "group";
-  else if ( mType == Vector )
+  else if ( type == Vector )
 #if GRASS_VERSION_MAJOR < 7
     return "vect";
 #else
     return "vector";
 #endif
-  else if ( mType == Region )
+  else if ( type == Region )
     return "region";
+  else if ( type == Strds )
+    return "strds";
+  else if ( type == Stvds )
+    return "stvds";
+  else if ( type == Str3ds )
+    return "str3ds";
   else
     return "";
 }
@@ -1462,9 +1473,56 @@ QStringList QgsGrass::elements( const QString&  mapsetPath, const QString&  elem
   return list;
 }
 
-QStringList QgsGrass::grassObjects( const QString& mapsetPath, QgsGrassObject::Type type )
+QStringList QgsGrass::grassObjects( const QgsGrassObject& mapsetObject, QgsGrassObject::Type type )
 {
-  return QgsGrass::elements( mapsetPath, QgsGrassObject::dirName( type ) );
+  QgsDebugMsg( "mapsetPath = " + mapsetObject.mapsetPath() + " type = " +  QgsGrassObject::elementShort( type ) );
+  QTime time;
+  time.start();
+  QStringList list;
+  if ( !QDir( mapsetObject.mapsetPath() ).isReadable() )
+  {
+    QgsDebugMsg( "mapset is not readable" );
+    return QStringList();
+  }
+  else if ( type == QgsGrassObject::Strds || type == QgsGrassObject::Stvds || type == QgsGrassObject::Str3ds )
+  {
+    QString cmd =  gisbase() + "/scripts/t.list";
+    QStringList arguments;
+
+    // Running t.list module is quite slow (about 500ms) -> check first if temporal db exists.
+    // Also, if tgis/sqlite.db does not exist, it is created by t.list for current mapset!
+    // If user is not owner of the mapset (even if has read permission) t.list fails because it checks ownership.
+    if ( !QFile( mapsetObject.mapsetPath() + "/tgis/sqlite.db" ).exists() )
+    {
+      QgsDebugMsg( "tgis/sqlite.db does not exist" );
+    }
+    else
+    {
+      arguments << "type=" + QgsGrassObject::elementShort( type );
+
+      int timeout = -1; // What timeout to use? It can take long time on network or database
+      QByteArray data = runModule( mapsetObject.gisdbase(), mapsetObject.location(), mapsetObject.mapset(), cmd, arguments, timeout, false );
+      Q_FOREACH ( QString fullName, QString::fromLocal8Bit( data ).split( '\n' ) )
+      {
+        fullName = fullName.trimmed();
+        if ( !fullName.isEmpty() )
+        {
+          QStringList nameMapset = fullName.split( "@" );
+          if ( nameMapset.value( 1 ) == mapsetObject.mapset() || nameMapset.value( 1 ).isEmpty() )
+          {
+            list << nameMapset.value( 0 );
+          }
+        }
+      }
+    }
+  }
+  else
+  {
+    list = QgsGrass::elements( mapsetObject.mapsetPath(), QgsGrassObject::dirName( type ) );
+  }
+  QgsDebugMsg( "list = " + list.join( "," ) );
+  QgsDebugMsg( QString( "time (ms) = %1" ).arg( time.elapsed() ) );
+  return list;
 }
 
 bool QgsGrass::objectExists( const QgsGrassObject& grassObject )
@@ -1893,6 +1951,7 @@ QProcess *QgsGrass::startModule( const QString& gisdbase, const QString&  locati
   QStringList environment = QProcess::systemEnvironment();
   environment.append( "GISRC=" + gisrcFile.fileName() );
   environment.append( "GRASS_MESSAGE_FORMAT=gui" );
+  environment.append( "GRASS_SKIP_MAPSET_OWNER_CHECK=1" );
 
   process->setEnvironment( environment );
 
@@ -1911,6 +1970,8 @@ QByteArray QgsGrass::runModule( const QString& gisdbase, const QString&  locatio
                                 const QStringList& arguments, int timeOut, bool qgisModule )
 {
   QgsDebugMsg( QString( "gisdbase = %1 location = %2 timeOut = %3" ).arg( gisdbase, location ).arg( timeOut ) );
+  QTime time;
+  time.start();
 
   QTemporaryFile gisrcFile;
   QProcess *process = startModule( gisdbase, location, mapset, moduleName, arguments, gisrcFile, qgisModule );
@@ -1927,6 +1988,7 @@ QByteArray QgsGrass::runModule( const QString& gisdbase, const QString&  locatio
                                      process->readAllStandardError().constData() ) );
   }
   QByteArray data = process->readAllStandardOutput();
+  QgsDebugMsg( QString( "time (ms) = %1" ).arg( time.elapsed() ) );
   delete process;
   return data;
 }
diff --git a/src/providers/grass/qgsgrass.h b/src/providers/grass/qgsgrass.h
@@ -81,7 +81,9 @@ class GRASS_LIB_EXPORT QgsGrassObject
 {
   public:
     //! Element type
-    enum Type { None, Location, Mapset, Raster, Group, Vector, Region };
+    enum Type { None, Location, Mapset, Raster, Group, Vector, Region,
+                Strds, Stvds, Str3ds
+            };
 
     QgsGrassObject() : mType( None ) {}
     QgsGrassObject( const QString& gisdbase, const QString& location = QString::null,
@@ -108,6 +110,7 @@ class GRASS_LIB_EXPORT QgsGrassObject
     // set from QGIS layer uri, returns true if set correctly, verifies also if location is a GRASS location
     bool setFromUri( const QString& uri );
     // element name used as modules param, e.g. g.remove element=name
+    static QString elementShort( Type type );
     QString elementShort() const;
     // descriptive full name
     QString elementName() const;
@@ -315,7 +318,7 @@ class GRASS_LIB_EXPORT QgsGrass : public QObject
     static QStringList elements( const QString&  mapsetPath, const QString&  element );
 
     //! List of existing objects
-    static QStringList grassObjects( const QString& mapsetPath, QgsGrassObject::Type type );
+    static QStringList grassObjects( const QgsGrassObject& mapsetObject, QgsGrassObject::Type type );
 
     // returns true if object (vector, raster, region) exists
     static bool objectExists( const QgsGrassObject& grassObject );
diff --git a/src/providers/grass/qgsgrassprovidermodule.cpp b/src/providers/grass/qgsgrassprovidermodule.cpp
@@ -142,7 +142,7 @@ void QgsGrassItemActions::renameGrassObject()
 {
   QgsDebugMsg( "Entered" );
 
-  QStringList existingNames = QgsGrass::grassObjects( mGrassObject.mapsetPath(), mGrassObject.type() );
+  QStringList existingNames = QgsGrass::grassObjects( mGrassObject, mGrassObject.type() );
   // remove current name to avoid warning that exists
   existingNames.removeOne( mGrassObject.name() );
   QgsDebugMsg( "existingNames = " + existingNames.join( "," ) );
@@ -200,7 +200,7 @@ QString QgsGrassItemActions::newVectorMap()
 {
   QgsDebugMsg( "entered" );
 
-  QStringList existingNames = QgsGrass::grassObjects( mGrassObject.mapsetPath(), QgsGrassObject::Vector );
+  QStringList existingNames = QgsGrass::grassObjects( mGrassObject, QgsGrassObject::Vector );
   QgsDebugMsg( "existingNames = " + existingNames.join( "," ) );
   QRegExp regExp = QgsGrassObject::newNameRegExp( QgsGrassObject::Vector );
   Qt::CaseSensitivity caseSensitivity = QgsGrass::caseSensitivity();

Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,7 @@ QgsGrassModuleInputModel::QgsGrassModuleInputModel( QObject *parent )`
`64`	`64`
`65`	`65`	`mWatcher = new QFileSystemWatcher( this );`
`66`	`66`	`connect( mWatcher, SIGNAL( directoryChanged( const QString & ) ), SLOT( onDirectoryChanged( const QString & ) ) );`
	`67`	`+ connect( mWatcher, SIGNAL( fileChanged( const QString & ) ), SLOT( onFileChanged( const QString & ) ) );`
`67`	`68`
`68`	`69`	`connect( QgsGrass::instance(), SIGNAL( mapsetChanged() ), SLOT( onMapsetChanged() ) );`
`69`	`70`
`@@ -80,7 +81,7 @@ void QgsGrassModuleInputModel::onDirectoryChanged( const QString & path )`
`80`	`81`	`QDir parentDir( path );`
`81`	`82`	`parentDir.cdUp();`
`82`	`83`	`QString mapset;`
`83`		`-`
	`84`	`+ QList<QgsGrassObject::Type> types;`
`84`	`85`	`if ( path == locationPath )`
`85`	`86`	`{`
`86`	`87`	`QgsDebugMsg( "location = " + path );`
`@@ -117,25 +118,58 @@ void QgsGrassModuleInputModel::onDirectoryChanged( const QString & path )`
`117`	`118`	`{`
`118`	`119`	`watch( path + "/" + watchedDir );`
`119`	`120`	`}`
	`121`	`+ // TODO: use db path defined in mapset VAR`
	`122`	`+ watch( path + "/tgis/sqlite.db" );`
`120`	`123`	`}`
`121`	`124`	`else // cellhd or vector dir`
`122`	`125`	`{`
`123`	`126`	`QgsDebugMsg( "cellhd/vector = " + path );`
`124`	`127`	`mapset = parentDir.dirName();`
	`128`	`+ if ( path.endsWith( "cellhd" ) )`
	`129`	`+ {`
	`130`	`+ types << QgsGrassObject::Raster;`
	`131`	`+ }`
	`132`	`+ else if ( path.endsWith( "vector" ) )`
	`133`	`+ {`
	`134`	`+ types << QgsGrassObject::Vector;`
	`135`	`+ }`
`125`	`136`	`}`
`126`	`137`	`if ( !mapset.isEmpty() )`
`127`	`138`	`{`
`128`	`139`	`QList<QStandardItem *> items = findItems( mapset );`
`129`	`140`	`if ( items.size() == 1 )`
`130`	`141`	`{`
`131`		`- refreshMapset( items[0], mapset );`
	`142`	`+ refreshMapset( items[0], mapset, types );`
	`143`	`+ }`
	`144`	`+ }`
	`145`	`+}`
	`146`	`+`
	`147`	`+void QgsGrassModuleInputModel::onFileChanged( const QString & path )`
	`148`	`+{`
	`149`	`+ QgsDebugMsg( "path = " + path );`
	`150`	`+ // when tgis/sqlite.db is changed, this gets called twice, probably the file changes more times when it is modified`
	`151`	`+ if ( path.endsWith( "/tgis/sqlite.db" ) )`
	`152`	`+ {`
	`153`	`+ QDir dir = QFileInfo( path ).dir();`
	`154`	`+ dir.cdUp();`
	`155`	`+ QString mapset = dir.dirName();`
	`156`	`+ QList<QStandardItem *> items = findItems( mapset );`
	`157`	`+ if ( items.size() == 1 )`
	`158`	`+ {`
	`159`	`+ QList<QgsGrassObject::Type> types;`
	`160`	`+ types << QgsGrassObject::Strds << QgsGrassObject::Stvds << QgsGrassObject::Str3ds;`
	`161`	`+ refreshMapset( items[0], mapset, types );`
`132`	`162`	`}`
`133`	`163`	`}`
`134`	`164`	`}`
`135`	`165`
`136`	`166`	`void QgsGrassModuleInputModel::watch( const QString & path )`
`137`	`167`	`{`
`138`		`- if ( !mWatcher->directories().contains( path ) && QFileInfo( path ).exists() )`
	`168`	`+ if ( QFileInfo( path ).isDir() && !mWatcher->directories().contains( path ) )`
	`169`	`+ {`
	`170`	`+ mWatcher->addPath( path );`
	`171`	`+ }`
	`172`	`+ else if ( QFileInfo( path ).isFile() && !mWatcher->files().contains( path ) )`
`139`	`173`	`{`
`140`	`174`	`mWatcher->addPath( path );`
`141`	`175`	`}`
`@@ -163,19 +197,24 @@ void QgsGrassModuleInputModel::addMapset( const QString & mapset )`
`163`	`197`	`appendRow( mapsetItem );`
`164`	`198`	`}`
`165`	`199`
`166`		`-void QgsGrassModuleInputModel::refreshMapset( QStandardItem *mapsetItem, const QString & mapset )`
	`200`	`+void QgsGrassModuleInputModel::refreshMapset( QStandardItem *mapsetItem, const QString & mapset, const QList<QgsGrassObject::Type> & theTypes )`
`167`	`201`	`{`
`168`	`202`	`QgsDebugMsg( "mapset = " + mapset );`
`169`	`203`	`if ( !mapsetItem )`
`170`	`204`	`{`
`171`	`205`	`return;`
`172`	`206`	`}`
`173`	`207`
`174`		`- QList<QgsGrassObject::Type> types;`
`175`		`- types << QgsGrassObject::Raster << QgsGrassObject::Vector;`
	`208`	`+ QList<QgsGrassObject::Type> types = theTypes;`
	`209`	`+ if ( types.isEmpty() )`
	`210`	`+ {`
	`211`	`+ types << QgsGrassObject::Raster << QgsGrassObject::Vector;`
	`212`	`+ types << QgsGrassObject::Strds << QgsGrassObject::Stvds << QgsGrassObject::Str3ds;`
	`213`	`+ }`
`176`	`214`	`foreach ( QgsGrassObject::Type type, types )`
`177`	`215`	`{`
`178`		`- QStringList maps = QgsGrass::grassObjects( QgsGrass::getDefaultGisdbase() + "/" + QgsGrass::getDefaultLocation() + "/" + mapset, type );`
	`216`	`+ QgsGrassObject mapsetObject( QgsGrass::getDefaultGisdbase(), QgsGrass::getDefaultLocation(), mapset, "", QgsGrassObject::Mapset );`
	`217`	`+ QStringList maps = QgsGrass::grassObjects( mapsetObject, type );`
`179`	`218`	`QStringList mapNames;`
`180`	`219`	`foreach ( const QString& map, maps )`
`181`	`220`	`{`
`@@ -230,9 +269,16 @@ void QgsGrassModuleInputModel::refreshMapset( QStandardItem *mapsetItem, const Q`
`230`	`269`
`231`	`270`	`void QgsGrassModuleInputModel::reload()`
`232`	`271`	`{`
	`272`	`+`
`233`	`273`	`QgsDebugMsg( "entered" );`
`234`		`- mWatcher->removePaths( mWatcher->files() );`
`235`		`- mWatcher->removePaths( mWatcher->directories() );`
	`274`	`+ if ( !mWatcher->files().isEmpty() )`
	`275`	`+ {`
	`276`	`+ mWatcher->removePaths( mWatcher->files() );`
	`277`	`+ }`
	`278`	`+ if ( !mWatcher->directories().isEmpty() )`
	`279`	`+ {`
	`280`	`+ mWatcher->removePaths( mWatcher->directories() );`
	`281`	`+ }`
`236`	`282`
`237`	`283`	`clear();`
`238`	`284`
`@@ -258,6 +304,7 @@ void QgsGrassModuleInputModel::reload()`
`258`	`304`	`{`
`259`	`305`	`watch( dirPath + "/" + watchedDir );`
`260`	`306`	`}`
	`307`	`+ watch( dirPath + "/tgis/sqlite.db" );`
`261`	`308`	`}`
`262`	`309`	`}`
`263`	`310`
`@@ -825,6 +872,18 @@ QgsGrassModuleInput::QgsGrassModuleInput( QgsGrassModule *module,`
`825`	`872`	`{`
`826`	`873`	`mType = QgsGrassObject::Raster;`
`827`	`874`	`}`
	`875`	`+ else if ( element == "strds" )`
	`876`	`+ {`
	`877`	`+ mType = QgsGrassObject::Strds;`
	`878`	`+ }`
	`879`	`+ else if ( element == "stvds" )`
	`880`	`+ {`
	`881`	`+ mType = QgsGrassObject::Stvds;`
	`882`	`+ }`
	`883`	`+ else if ( element == "str3ds" )`
	`884`	`+ {`
	`885`	`+ mType = QgsGrassObject::Str3ds;`
	`886`	`+ }`
`828`	`887`	`else`
`829`	`888`	`{`
`830`	`889`	`mErrors << tr( "GRASS element %1 not supported" ).arg( element );`
Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,6 @@ class QgsGrassToolsTreeFilterProxyModel : public QSortFilterProxyModel`
`128`	`128`
`129`	`129`	`for ( int i = 0; i < mModel->rowCount( sourceIndex ); i++ )`
`130`	`130`	`{`
`131`		`- QgsDebugMsg( QString( "i = %1" ).arg( i ) );`
`132`	`131`	`QModelIndex sourceChildIndex = mModel->index( i, 0, sourceIndex );`
`133`	`132`	`if ( filterAcceptsItem( sourceChildIndex ) )`
`134`	`133`	`return true;`