QGIS » QGIS Application

    QgsGrass::setLocation( sel->gisdbase, sel->location );

    /* Open vector */

      if ( level >= 2 )

      {

        // Count layers

      Vect_close( &map );

    }

    {

    }

    qGisInterface->addVectorLayer( uri, name, "grass" );

                       QgsGrass::getDefaultLocation(),

                       QgsGrass::getDefaultMapset() );

  {

#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \

  ( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR >= 4 ) || GRASS_VERSION_MAJOR > 6 )

#else

#endif

  // Open in GRASS vector provider

  QString uri = QgsGrass::getDefaultGisdbase() + "/"

    int ret = 0;

    {

      ret = G_make_location( location.toAscii().data(), &mCellHead, mProjInfo, mProjUnits, stdout );

    }

    {

      QMessageBox::warning( this, tr( "Create location" ),

      return;

    }

class QgsGrassModelItem

{

  public:

    QgsGrassModelItem();

    ~QgsGrassModelItem();

QgsGrassModelItem::~QgsGrassModelItem()

{

  {

    delete mChildren[i];

  }

  // Add new items

  {

    QString name = list.at( i );

// QgsDebugMsg(QString("? add %1").arg(name));

    int insertAt = item->mChildren.size();

    {

      if ( item->mChildren[i]->name() == name )

      {

      default:

        return mIconDirectory;

    }

  }

  return item->data( role );

}

  // Call to setjmp() returns 0 first time. In case of fatal error,

  // our error routine uses longjmp() to come back to this context,

  // this time setjmp() will return non-zero value and we can continue...

  {

    level = Vect_open_old_head( &map, ( char * ) mapName.toAscii().data(), ( char * ) mapset.toAscii().data() );

  }

  {

    return list;

  }

{

  // show title if provided

  if ( !mTitle.isNull() )

    QgsDebugMsg( QString( "%1:" ).arg( mTitle ) );

  // show the message

  QgsDebugMsg( mMessage );

  emit destroyed();

#include <grass/form.h>

}

#include <QString>

/*!

   Methods for C library initialization and error handling.

*/

class QgsGrass

{

  public:

    //! Get info about the mode

    /*! QgsGrass may be running in active or passive mode.

     *  Active mode means that GISRC is set up and GISRC file is available,

    */

    static GRASS_EXPORT void setMapset( QString gisdbase, QString location, QString mapset );

    enum GERROR { OK, /*!< OK. No error. */

              };

    //! Map type

    static GRASS_EXPORT void resetError( void );  // reset error status

    //! Check if any error occured in lately called functions. Returns value from ERROR.

    //! Get last error message

    /** \brief Open existing GRASS mapset

     * \return NULL string or error message

    static GRASS_EXPORT int versionRelease();

    static GRASS_EXPORT QString versionString();

  private:

    static int initialized; // Set to 1 after initialization

    static bool active; // is active mode

    static QString defaultMapset;

    /* last error in GRASS libraries */

    static QString error_message;

    // G_set_error_routine has two versions of the function's first argument it expects:

    static QString mGisrc;

    // Temporary directory where GISRC and sockets are stored

    static QString mTmp;

};

#endif // QGSGRASS_H

  mValid = false;

  // Getting the total number of features in the layer

  // It may happen that the field disappeares from the map (deleted features, new map without that field)

  if ( isEdited() || isFrozen() || !mValid )

    return false;

  // Get next line/area id

  int found = 0;

    Vect_cidx_get_cat_by_index( mMap, mCidxFieldIndex, mNextCidx++, &cat, &type, &id );

    // Warning: selection array is only of type line/area of current layer -> check type first

    found = 1;

    break;

  }

#if QGISDEBUG > 3

  QgsDebugMsg( QString( "cat = %1 type = %2 id = %3" ).arg( cat ).arg( type ).arg( id ) );

#endif

  // Open map

  QgsGrass::init();

  {

    layer.mapId = openMap( gisdbase, location, mapset, mapName );

  }

  {

    return -1;

  }

  // Do we have topology and cidx (level2)

  int level = 2;

  {

  }

  {

  }

  if ( level == 1 )

  {

    QMessageBox::StandardButton ret = QMessageBox::question( 0, "Warning",

                                      QMessageBox::Ok | QMessageBox::Cancel );

    if ( ret == QMessageBox::Cancel ) return -1;

  }

  // Open vector

  {

    return -1;

  }

  if ( level == 1 )

  {

#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \

    ( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR >= 4 ) || GRASS_VERSION_MAJOR > 6 )

#else

#endif

    {

      return -1;

    }

  }

  // TODO: Is it necessary for close ?

  G__setenv(( char * )"MAPSET", map->mapset.toAscii().data() );

  QFileInfo di( map->gisdbase + "/" + map->location + "/" + map->mapset + "/vector/" + map->mapName );

  map->lastModified = di.lastModified();

  map->lastAttributesModified = di.lastModified();

  // Reopen vector

  {

    Vect_open_old( map->map, map->mapName.toAscii().data(), map->mapset.toAscii().data() );

  }

  {

    // if reopen fails, mLayers should be also updated

    for ( unsigned int i = 0; i <  mLayers.size(); i++ )

      bool mapsetunset = G__getenv( "MAPSET" ) == NULL || *G__getenv( "MAPSET" ) == 0;

      if ( mapsetunset )

        G__setenv(( char * )"MAPSET", mMaps[mapId].mapset.toAscii().data() );

      if ( mapsetunset )

        G__setenv(( char * )"MAPSET", "" );

    }

    GATT *att = ( GATT * ) bsearch( &key, mLayers[layerId].attributes, mLayers[layerId].nAttributes,

                                    sizeof( GATT ), cmpAtt );

    {

      if ( att != NULL )

      {

  const char *oldlocale = setlocale( LC_NUMERIC, NULL );

  setlocale( LC_NUMERIC, "C" );

  {

    G_get_default_window( &cellhd );

  }

  {

    setlocale( LC_NUMERIC, oldlocale );

    return QgsCoordinateReferenceSystem();

  }

  Vect_close( map->map );

  // TODO: Catch error

  {

    {

      QgsDebugMsg( "Cannot open GRASS vector for update on level 2." );

    }

    // reopen vector for reading

    {

      {

      }

    }

    {

    }

    return false;

  }

  Vect_set_category_index_update( map->map );

  map->lastAttributesModified = di.lastModified();

  // Reopen vector

  {

    return false;

  }

 *                                                                         *

 ***************************************************************************/

#include <string.h>

#include <vector>

#include <cfloat>

  // Set error function

  G_set_error_routine( &error_routine );

  QSettings settings;

bool QgsGrass::active = 0;

QString QgsGrass::error_message;

QString QgsGrass::mGisrc;

QString QgsGrass::mTmp;

int QgsGrass::error_routine( char *msg, int fatal )

{

  return error_routine(( const char* ) msg, fatal );

  if ( fatal )

  {

    // we have to do a long jump here, otherwise GRASS >= 6.3 will kill our process

  }

  else

  return 1;

}

void GRASS_EXPORT QgsGrass::resetError( void )

{

}

{

}

{

  return error_message;

}

QString GRASS_EXPORT QgsGrass::openMapset( QString gisdbase, QString location, QString mapset )

{

  QgsDebugMsg( QString( "gisdbase = %1" ).arg( gisdbase.toLocal8Bit().constData() ) );