QGIS » QGIS Application

- QVector< QVector<TYPE> >

- QVector< QVector< QVector<TYPE> > >

- QSet<int>

- QSet<TYPE>

- QMap<QString, QVariant::Type>

- QMap<TYPE1, TYPE2*>

- QMultiMap<double, TYPE2>

};

template <TYPE>

%MappedType QSet<TYPE>

{

  *sipCppPtr = qset;

  return sipGetState(sipTransferObj);

%End

};

template<TYPE>

{

%TypeHeaderCode

#include <QMap>

%End

  const sipMappedType* qmap2 = sipFindMappedType("QMap<int, TYPE>");

  // Set the list elements.

  {

    QMap<int, TYPE>* t = new QMap<int, TYPE>(*it);

    PyObject *tobj = sipConvertFromMappedType(t, qmap2, sipTransferObj);

    if (kobj == NULL || tobj == NULL || PyDict_SetItem(d, kobj, tobj) < 0)

    return 1;

  }

  Py_ssize_t i = 0;

  while (PyDict_Next(sipPy, &i, &kobj, &tobj))

  {

    // using sipConvertToMappedType to convert directly to QMap<int, TYPE> doesn't work

    // and ends with a segfault

  *sipCppPtr = qm;

  return sipGetState(sipTransferObj);

%End

};

%MappedType QMap<QString, QVariant::Type>

    return sipGetState(sipTransferObj);

%End

    typedef unsigned int size_t;

    //! Constructor

    /** copy ctor needed due to internal pointer */

    QgsFeature(const QgsFeature & rhs );

     * Get the feature id for this feature

     * @return Feature id

     */

    /**

     * Set the feature id for this feature

     * @param id Feature id

     */

    /** returns the feature's type name

  QList<QgsFeature> selectedFeatures();

  /** Return reference to identifiers of selected features */

  /** Change selection to the new set of features */

  /** Returns the bounding box of the selected features. If there is no selection, QgsRect(0,0,0,0) is returned */

  QgsRect boundingBoxOfSelected();

   *  in the given ring, item (first number is index 0), and feature

   *  Not meaningful for Point geometries

   */

  /** Moves the vertex at the given position number,

   *  ring and item (first number is index 0), and feature

   *  to the given coordinates

   */

  /** Deletes the vertex at the given position number,

   *  ring and item (first number is index 0), and feature

   */

  /** Deletes the selected features

   *  @return true in case of success and false otherwise

     @param dx translation of x-coordinate

     @param dy translation of y-coordinate

     @return 0 in case of success*/

  /**Splits features cut by the given line

     @param splitLine line that splits the layer features

  bool startEditing();

  /** changed an attribute value (but does not commit it */

  /** add an attribute field (but does not commit it) 

      returns the field index or -1 in case of failure */

public slots:

  /** Select feature by its ID, optionally emit signal selectionChanged() */

  /** Clear selection */

  void removeSelection(bool emitSignal = TRUE);

  void editingStopped();

  void attributeAdded(int idx);

  void attributeDeleted(int idx);

  void layerDeleted();

private:                       // Private methods

       * @param fetchAttributes a list containing the indexes of the attribute fields to copy

       * @return True when feature was found, otherwise false

       */

                                  QgsFeature& feature,

                                  bool fetchGeometry = true,

                                  QList<int> fetchAttributes = QList<int>());

       * @param id list containing feature ids to delete

       * @return true in case of success and false in case of failure

       */

      /**

       * Adds new attributes

       * @param attr_map a map containing changed attributes

       * @return true in case of success and false in case of failure 

       */

      /**

       * Returns the default value for field specified by @c fieldId

       *                       the second map parameter being the new geometries themselves

       * @return               true in case of success and false in case of failure

       */

      /**

       * Creates a spatial index on the datasource (if supported by the provider type).

#define QGSIDENTIFYRESULTS_H

#include "ui_qgsidentifyresultsbase.h"

#include "qgsattributeaction.h"

#include <QWidget>

#include <vector>

#include <map>

    void addDerivedAttribute( QTreeWidgetItem *parent, QString field, QString value );

    /** Add an action to the feature display node */

    /** Add an edit action to the feature display node */

    /** Add a feature node to the feature display */

    QTreeWidgetItem * addNode( QString label );

    //void reject();

  signals:

  public slots:

  {

    for ( int index = range_it->topRow(); index <= range_it->bottomRow(); index++ )

    {

    }

  }

  //todo: don't repaint in case of double clicks

}

{

  rowIdMap.insert( id, row );

}

{

  setRangeSelected( QTableWidgetSelectionRange( it.value(), 0, it.value(), columnCount() - 1 ), true );

}

  }

  //id-field

  twi->setTextAlignment( Qt::AlignRight | Qt::AlignVCenter );

  setItem( row, 0, twi );

  insertFeatureId( id, row );  //insert the id into the search tree of qgsattributetable

  }

}

{

  if ( !rowIdMap.contains( fid ) )

    return;

  item( rowIdMap[fid], mAttrIdxMap[idx] )->setText( v );

}

{

  if ( !rowIdMap.contains( fid ) )

    return;

  removeRow( row );

    if ( it.value() > row )

      rowIdMap[ it.key()]--;

}

    /* Inserts the feature with the specified id into rowIdMap. This function has to be called

       (e.g. from QgsShapeFileLayer) when a row is inserted into the table */

    /**Selects the row which belongs to the feature with the specified id*/

    /**Sorts a column. If the first entry contains a letter, sort alphanumerically, otherwise numerically.*/

    void sortColumn( int col, bool ascending );

    /* Use this to give this class the current attribute actions,

    // Called when the user chooses an item on the popup menu

    void popupItemSelected( QAction * menuAction );

  protected slots:

    void handleChangedSelections();

    /**Flag telling if the ctrl-button or the shift-button is pressed*/

    bool lockKeyPressed;

    /**Search tree to find a row corresponding to a feature id*/

    /**Map attribute index to columns*/

    QMap<int, int> mAttrIdxMap;

    bool mEditable;

  signals:

    /**Is emitted when a row was selected*/

    /**Is emitted when all rows have been deselected*/

    void selectionRemoved( bool );

    /**Is emitted when a set of related selection and deselection signals have been emitted*/

    QgsRubberBand* mRubberBand;

    /**Id of moved feature*/

};

#endif

        {

          connect( mColumnTypeThread, SIGNAL( setLayerType( QString, QString, QString, QString ) ),

                   this, SLOT( setLayerType( QString, QString, QString, QString ) ) );

                   mColumnTypeThread, SLOT( stop() ) );

          // Do it in a thread.

    // Be informed when the dialog box is closed so that we can stop using it.

    connect( mResults, SIGNAL( accepted() ), this, SLOT( resultsDialogGone() ) );

    connect( mResults, SIGNAL( rejected() ), this, SLOT( resultsDialogGone() ) );

    // restore the identify window position and show it

    mResults->restorePosition();

  QApplication::setOverrideCursor( Qt::WaitCursor );

  QgsFeatureList::iterator f_it = mFeatureList.begin();

  for ( ; f_it != mFeatureList.end(); ++f_it )

  QgsMapTool::deactivate();

}

{

  QgsVectorLayer* layer = dynamic_cast<QgsVectorLayer*>( mLayer );

  if ( !layer )

  }

}

{

  for ( QgsFeatureList::iterator it = mFeatureList.begin(); it != mFeatureList.end(); it++ )

  {

  new QTreeWidgetItem( daRootNode, labels );

}

{

  QStringList labels;

  QTreeWidgetItem *item = new QTreeWidgetItem( fnode, labels );

  item->setIcon( 0, QgisApp::getThemeIcon( "/mIconEditable.png" ) );

}

{

  QStringList labels;

  QTreeWidgetItem *item = new QTreeWidgetItem( fnode, labels );

  item->setIcon( 0, QgisApp::getThemeIcon( "/mAction.png" ) );

  connect( mLayer, SIGNAL( attributeAdded( int ) ), this, SLOT( attributeAdded( int ) ) );

  connect( mLayer, SIGNAL( attributeDeleted( int ) ), this, SLOT( attributeDeleted( int ) ) );

  // etablish connections between table and vector layer

  connect( tblAttributes, SIGNAL( selectionRemoved( bool ) ), mLayer, SLOT( removeSelection( bool ) ) );

  connect( tblAttributes, SIGNAL( repaintRequested() ), mLayer, SLOT( triggerRepaint() ) );

  public slots:

    //! creates rubberband on top of the feature to highlight it

    //! edit a feature

  private:

 * \brief Encapsulates a spatial feature with attributes

 */

    : mFid( id ),

    mGeometry( 0 ),

    mOwnsGeometry( 0 ),

 * Get the feature id for this feature

 * @return Feature id

 */

{

  return mFid;

}

/** Set the feature id

*/

{

  mFid = id;

}

  }

}

{

  if ( emitSignal )

  {

      // check if changed geometries are in rectangle

      for ( ; mFetchChangedGeomIt != mChangedGeometries.end(); mFetchChangedGeomIt++ )

      {

        if ( mFetchConsidered.contains( fid ) )

          // skip deleted features

        if ( mFetchAttributes.size() > 0 )

        {

          {

            // fid<0 => in mAddedFeatures

            bool found = false;

    for ( ; mFetchAddedFeaturesIt != mAddedFeatures.end(); mFetchAddedFeaturesIt++ )

    {

      if ( mFetchConsidered.contains( fid ) )

        // must have changed geometry outside rectangle

  return false;

}

{

  if ( !mDataProvider )

    return 1;

    if ( fetchAttributes )

    {

      {

        // featureId<0 => in mAddedFeatures

        bool found = false;

}

{

  if ( !mEditable )

  {

}

{

  if ( !mEditable )

  {

}

{

  if ( !mEditable )

  {

  while ( mSelectedFeatureIds.size() > 0 )

  {

    deleteFeature( fid );  // removes from selection

  }

    return 5;

  }

  //look if geometry of selected feature already contains geometry changes

  QgsGeometryMap::iterator changedIt = mChangedGeometries.find( selectedFeatureId );

  return 6; //geometry not found

}

{

  //look if geometry of selected feature already contains geometry changes

  QgsGeometryMap::iterator changedIt = mChangedGeometries.find( featureId );

    QgsFeature f;

    while ( getNextFeature( f ) )

  }

  QgsFeatureList::iterator select_it = featureList.begin();

  return true;

} // bool QgsVectorLayer::writeXml

{

  if ( !isEditable() )

    return false;

  {

    // changed attribute of existing feature

    if ( !mChangedAttributeValues.contains( fid ) )

  return true;

}

{

  if ( !isEditable() )

    return false;

  return n == 0 ? 2 : 0;

}

                                     QMultiMap<double, QgsSnappingResult>& snappingResults, QgsSnapper::SNAP_TO snap_to ) const

{

  if ( !geom )

  return -1;

}

{

  select( fetchAttributes, QgsRect(), fetchGeometry );

#include <QString>

#include <QVariant>

#include <QList>

class QgsGeometry;

class QgsRect;

class QgsFeature;

/** \ingroup core

 * The feature class encapsulates a single feature including its id,

 * geometry and a list of field/values attributes.

class CORE_EXPORT QgsFeature

{

  public:

    //! Constructor

    /** copy ctor needed due to internal pointer */

    QgsFeature( QgsFeature const & rhs );

    //! Destructor

    ~QgsFeature();

    /**

     * Get the feature id for this feature

     * @return Feature id

     */

    /**

     * Set the feature id for this feature

     * @param id Feature id

     */

    /** returns the feature's type name

  private:

    //! feature id

    /** map of attributes accessed by field index */

    QgsAttributeMap mAttributes;

    /// feature type name

    QString mTypeName;

}; // class QgsFeature

#endif

class QgsRect;

typedef QList<int> QgsAttributeList;

typedef QSet<int> QgsAttributeIds;

/** \ingroup core

    /**Gets the feature at the given feature id. Considers the changed, added, deleted and permanent features

     @return 0 in case of success*/

    /** Adds a feature

        @param lastFeatureInBatch  If True, will also go to the effort of e.g. updating the extents.

     *  in the given ring, item (first number is index 0), and feature

     *  Not meaningful for Point geometries

     */

    /** Moves the vertex at the given position number,

     *  ring and item (first number is index 0), and feature

     *  to the given coordinates

     */

    /** Deletes a vertex from a feature

     */

    /** Deletes the selected features

     *  @return true in case of success and false otherwise

       @param dx translation of x-coordinate

       @param dy translation of y-coordinate

       @return 0 in case of success*/

    /**Splits features cut by the given line

       @param splitLine line that splits the layer features

       @param snap_to to segment / to vertex

       @return 0 in case of success

    */

    /** Draws the layer

     *  @return FALSE if an error occurred during drawing

    /** \brief Draws the layer labels using coordinate transformation

     *  \param scale size scale, applied to all values in pixels

     */

    /** returns field list in the to-be-committed state */

    const QgsFieldMap &pendingFields();

    bool startEditing();

    /** changed an attribute value (but does not commit it */

    /** add an attribute field (but does not commit it)

        returns the field index or -1 in case of failure */

    bool addFeatures( QgsFeatureList features, bool makeSelected = TRUE );

    /** delete a feature from the layer (but does not commit it) */

    /**

      Attempts to commit any changes to disk.  Returns the result of the attempt.

  public slots:

    /** Select feature by its ID, optionally emit signal selectionChanged() */

    /** Clear selection */

    void removeSelection( bool emitSignal = TRUE );

    void editingStopped();

    void attributeAdded( int idx );

    void attributeDeleted( int idx );

    void layerDeleted();

  private:                       // Private methods

     @param snappingResult list to which the result is appended

     @param snap_to snap to vertex or to segment

    */

                         QMultiMap<double, QgsSnappingResult>& snappingResults, QgsSnapper::SNAP_TO snap_to ) const;

    /**Little helper function that gives bounding box from a list of points.

    QgsAttributeList mFetchNullAttributes;

    bool mFetchGeometry;

    QgsGeometryMap::iterator mFetchChangedGeomIt;

    QgsFeatureList::iterator mFetchAddedFeaturesIt;

};

/** \ingroup core

 * This is the base class for vector data providers.

 *

 * of feature and attrubute information from a spatial datasource.

 *

 *

     * Default implementation traverses all features until it finds the one with correct ID.

     * In case the provider supports reading the feature directly, override this function.

     */

                                 QgsFeature& feature,

                                 bool fetchGeometry = true,

                                 QgsAttributeList fetchAttributes = QgsAttributeList() );

    /**

     * Changes geometries of existing features

     *                       that will have their geometries changed.

     *                       The second map parameter being the new geometries themselves

     * @return               True in case of success and false in case of failure

  if ( !g )

    return false;

  r = rectToRegion( g->boundingBox() );

  return true;

}

#include "qgspoint.h"

#include <QList>

#include <QMultiMap>

class QgsMapRenderer;

class QgsVectorLayer;

   or -1 if no such vertex*/

  int afterVertexNr;

  /**Index of the snapped geometry*/

  /**Layer where the snap occured*/

  const QgsVectorLayer* layer;

};

                     QgsFeature &feature,

                     const QgsAttributeList &fetchAttributes );

    const QgsField &field( int index ) const;

    /** Double quote a PostgreSQL identifier for placement in a SQL string.

  //fill type names into sets

  mSupportedNativeTypes.insert( "double precision", QVariant::Double );

  mSupportedNativeTypes.insert( "int4", QVariant::Int );

  mSupportedNativeTypes.insert( "int8", QVariant::LongLong );

  mSupportedNativeTypes.insert( "text", QVariant::String );

  }

}

bool QgsPostgresProvider::getFeature( PGresult *queryResult, int row, bool fetchGeometry,

                                      QgsFeature &feature,

                                      const QgsAttributeList &fetchAttributes )

{

  try

  {

    feature.setFeatureId( oid );

    int col;  // first attribute column after geometry

        // oid isn't indexed (and that they may want to add a

        // primary key to the table)

        primaryKey = "oid";

      }

      else

      {

        showMessageBox( tr( "No suitable key column in table" ),

                        tr( "The table has no column suitable for use as a key.\n\n"

                            "Qgis requires that the table either has a column of type\n"

                            "primary key) or has a PostgreSQL oid column.\n" ) );

      }

    }

          QString columnName = QString::fromUtf8( PQgetvalue( types, 0, 0 ) );

          QString columnType = QString::fromUtf8( PQgetvalue( types, 0, 1 ) );

            log.append( tr( "The unique index on column" ) +

                        " '" + columnName + "' " +

                        tr( "is unsuitable because Qgis does not currently support"

          else

            suitableKeyColumns.push_back( std::make_pair( columnName, columnType ) );

        }

      if ( PQntuples( oidCheck ) != 0 )

      {

        primaryKey = "oid";

      }

      else

      {

        log.prepend( "There were no columns in the table that were suitable "

                     "as a qgis key into the table (either a column with a "

      }

    }

    // This sql returns one or more rows if the column 'tableCol' in

    // table 'tableName' and schema 'schemaName' has one or more

    // columns that satisfy the following conditions:

    // 2) the column has a unique constraint or primary key constraint

    //    on it.

    // 3) the constraint applies just to the column of interest (i.e.,

                   "and array_dims(conkey)='[1:1]'" ).arg( quotedValue( tableCol ) ).arg( rel_oid );

    result = connectionRO->PQexec( sql );

      suitable[viewCol] = iter->second;

    QString details = "'" + viewCol + "'" + tr( " derives from " )

                      + "'" + schemaName + "." + tableName + "." + tableCol + "' ";

    {

      details += tr( "and is suitable." );

    }

                     "of which satisfy the above conditions:" ) );

    log.prepend( tr( "Qgis requires that the view has a column that can be used "

                     "as a unique key. Such a column should be derived from "

                     "have a unique constraint on it, or be a PostgreSQL "

                     "oid column. To improve "

                     "performance the column should also be indexed.\n" ) );

    // cycle through the features

    for ( QgsChangedAttributesMap::const_iterator iter = attr_map.begin();iter != attr_map.end();++iter )

    {

      // skip added features

      if ( fid < 0 )

  swapEndian = true;

  if ( PQntuples( fResult ) > 0 )

  {

    // compare the two oid values to determine if we need to do an endian swap

      swapEndian = false;

  }

  connectionRO->closeCursor( "oidcursor" );

    /**Adds one feature*/

    bool addFeature( QgsFeature& f );

    /**Deletes one feature*/

};

{

  for ( QgsChangedAttributesMap::const_iterator it = attr_map.begin(); it != attr_map.end(); ++it )

  {

    OGRFeatureH of = OGR_L_GetFeature( ogrLayer, fid );

  for ( QgsGeometryMap::iterator it = geometry_map.begin(); it != geometry_map.end(); ++it )

  {

    if ( !theOGRFeature )

    {

      QgsLogger::warning( "QgsOgrProvider::changeGeometryValues, cannot find feature" );

  return returnvalue;

}

{

  return ( res == OGRERR_NONE );

}

#include "qgsvectordataprovider.h"

class QgsSpatialIndex;

void GPSData::removeWaypoints( const QgsFeatureIds & ids )

{

  qSort( ids2 );

  WaypointIterator wIter;

  for ( wIter = waypoints.begin();

        wIter != waypoints.end() && iter != ids2.end(); )

void GPSData::removeRoutes( const QgsFeatureIds & ids )

{

  qSort( ids2 );