QGIS » QGIS Application

        <file>themes/default/mActionAddIsland.png</file>

        <file>themes/gis/mActionAddIsland.png</file>

    virtual QAction *actionCapturePoint() = 0;

    virtual QAction *actionCaptureLine() = 0;

    virtual QAction *actionCapturePolygon() = 0;

    virtual QAction *actionAddIsland() = 0;

  qgsmaptooladdisland.cpp

  qgsmaptooladdisland.h

#include "qgsmaptooladdisland.h"

  delete mMapTools.mCapturePoint;

  delete mMapTools.mCaptureLine;

  delete mMapTools.mCapturePolygon;

#if 0 //these three tools to be deprecated - use node tool rather

  delete mMapTools.mVertexAdd;

  delete mMapTools.mVertexMove;

  delete mMapTools.mVertexDelete;

#endif

  delete mMapTools.mAddIsland;

  connect( mActionCapturePoint, SIGNAL( triggered() ), this, SLOT( capturePoint() ) );

  connect( mActionCaptureLine, SIGNAL( triggered() ), this, SLOT( captureLine() ) );

  connect( mActionCapturePolygon, SIGNAL( triggered() ), this, SLOT( capturePolygon() ) );

  connect( mActionAddIsland, SIGNAL( triggered() ), this, SLOT( addIsland() ) );

  mMapToolGroup->addAction( mActionCaptureLine );

  mMapToolGroup->addAction( mActionCapturePoint );

  mMapToolGroup->addAction( mActionCapturePolygon );

  mMapToolGroup->addAction( mActionAddIsland );

  mActionCapturePoint->setIcon( getThemeIcon( "/mActionCapturePoint.png" ) );

  mActionCaptureLine->setIcon( getThemeIcon( "/mActionCaptureLine.png" ) );

  mActionCapturePolygon->setIcon( getThemeIcon( "/mActionCapturePolygon.png" ) );

#if 0 //these three icons to be deprecated

  mActionAddVertex->setIcon( getThemeIcon( "/mActionAddVertex.png" ) );

  mActionMoveVertex->setIcon( getThemeIcon( "/mActionMoveVertex.png" ) );

  mActionDeleteVertex->setIcon( getThemeIcon( "/mActionDeleteVertex.png" ) );

#endif

  mActionAddIsland->setIcon( getThemeIcon( "/mActionAddIsland.png" ) );

  mMapTools.mCapturePoint = new QgsMapToolAddFeature( mMapCanvas, QgsMapToolCapture::CapturePoint );

  mMapTools.mCapturePoint->setAction( mActionCapturePoint );

  mActionCapturePoint->setVisible( false );

  mMapTools.mCaptureLine = new QgsMapToolAddFeature( mMapCanvas, QgsMapToolCapture::CaptureLine );

  mMapTools.mCaptureLine->setAction( mActionCaptureLine );

  mActionCaptureLine->setVisible( false );

  mMapTools.mCapturePolygon = new QgsMapToolAddFeature( mMapCanvas, QgsMapToolCapture::CapturePolygon );

  mMapTools.mCapturePolygon->setAction( mActionCapturePolygon );

  mActionCapturePolygon->setVisible( false );

#if 0 //these three tools to be deprecated - use node tool rather

  mMapTools.mVertexAdd = new QgsMapToolAddVertex( mMapCanvas );

  mMapTools.mVertexAdd->setAction( mActionAddVertex );

  mMapTools.mVertexMove = new QgsMapToolMoveVertex( mMapCanvas );

  mMapTools.mVertexMove->setAction( mActionMoveVertex );

  mMapTools.mVertexDelete = new QgsMapToolDeleteVertex( mMapCanvas );

  mMapTools.mVertexDelete->setAction( mActionDeleteVertex );

#endif

  mMapTools.mAddIsland = new QgsMapToolAddIsland( mMapCanvas );

void QgisApp::capturePoint()

{

  if ( mMapCanvas && mMapCanvas->isDrawing() )

  {

    return;

  }

  // set current map tool to select

  mMapCanvas->setMapTool( mMapTools.mCapturePoint );

}

void QgisApp::captureLine()

  mMapCanvas->setMapTool( mMapTools.mCaptureLine );

}

void QgisApp::capturePolygon()

{

  if ( mMapCanvas && mMapCanvas->isDrawing() )

  {

    return;

  }

  mMapCanvas->setMapTool( mMapTools.mCapturePolygon );

void QgisApp::addVertex()

{

  if ( mMapCanvas && mMapCanvas->isDrawing() )

  {

    return;

  }

  mMapCanvas->setMapTool( mMapTools.mVertexAdd );

}

void QgisApp::moveVertex()

{

  if ( mMapCanvas && mMapCanvas->isDrawing() )

  {

    return;

  }

  mMapCanvas->setMapTool( mMapTools.mVertexMove );

}

void QgisApp::addIsland()

{

  if ( mMapCanvas && mMapCanvas->isDrawing() )

  {

    return;

  }

  mMapCanvas->setMapTool( mMapTools.mAddIsland );

}

void QgisApp::deleteVertex()

  mMapCanvas->setMapTool( mMapTools.mVertexDelete );

    mActionCapturePoint->setEnabled( false );

    mActionCaptureLine->setEnabled( false );

    mActionCapturePolygon->setEnabled( false );

    mActionAddIsland->setEnabled( false );

    mActionCapturePoint->setVisible( false );

    mActionCaptureLine->setVisible( false );

    mActionCapturePolygon->setVisible( false );

        if ( vlayer->isEditable() && dprovider->capabilities() & QgsVectorDataProvider::AddFeatures )

        {

          mActionCapturePoint->setEnabled( true );

          mActionCapturePoint->setVisible( true );

          mActionDeletePart->setEnabled( true );

          mActionAddIsland->setEnabled( true );

        }

        else

        {

          mActionCapturePoint->setEnabled( false );

          mActionCapturePoint->setVisible( false );

          mActionDeletePart->setEnabled( false );

          mActionAddIsland->setEnabled( false );

        }

        mActionCaptureLine->setEnabled( false );

        mActionCapturePolygon->setEnabled( false );

        mActionCaptureLine->setVisible( false );

        mActionCapturePolygon->setVisible( false );

#if 0 //these three tools to be deprecated - use node tool rather

        mActionAddVertex->setEnabled( false );

        mActionDeleteVertex->setEnabled( false );

        mActionMoveVertex->setEnabled( false );

#endif

#if 0

        mActionAddIsland->setEnabled( false );

#endif

        mActionAddIsland->setEnabled( false );

#if 0

        if ( vlayer->isEditable() && dprovider->capabilities() & QgsVectorDataProvider::ChangeGeometries )

        {

          mActionMoveVertex->setEnabled( true );

        }

#endif

          mActionCaptureLine->setEnabled( true );

          mActionCaptureLine->setVisible( true );

          mActionDeletePart->setEnabled( true );

          mActionCaptureLine->setEnabled( false );

          mActionCaptureLine->setVisible( false );

          mActionDeletePart->setEnabled( false );

        mActionCapturePoint->setEnabled( false );

        mActionCapturePolygon->setEnabled( false );

        mActionCapturePoint->setVisible( false );

        mActionCapturePolygon->setVisible( false );

        mActionAddIsland->setEnabled( false );

          mActionCapturePolygon->setEnabled( true );

          mActionCapturePolygon->setVisible( true );

          mActionAddIsland->setEnabled( true );

          mActionDeletePart->setEnabled( true );

          mActionCapturePolygon->setEnabled( false );

          mActionCapturePolygon->setVisible( false );

          mActionAddIsland->setEnabled( false );

          mActionDeletePart->setEnabled( false );

        mActionCapturePoint->setEnabled( false );

        mActionCaptureLine->setEnabled( false );

        mActionCapturePoint->setVisible( false );

        mActionCaptureLine->setVisible( false );

      //are add/delete/move vertex supported?

      if ( vlayer->isEditable() && dprovider->capabilities() & QgsVectorDataProvider::ChangeGeometries )

      {

#if 0 // these three tools to be deprecated - use node tool rather

        mActionAddVertex->setEnabled( true );

        mActionMoveVertex->setEnabled( true );

        mActionDeleteVertex->setEnabled( true );

#endif

        if ( vlayer->geometryType() == QGis::Polygon )

        {

          mActionAddRing->setEnabled( true );

          //some polygon layers contain also multipolygon features.

          //Therefore, the test for multipolygon is done in QgsGeometry

          mActionAddIsland->setEnabled( true );

        }

      }

      else

      {

#if 0

        mActionAddVertex->setEnabled( false );

        mActionMoveVertex->setEnabled( false );

        mActionDeleteVertex->setEnabled( false );

#endif

      }

    mActionCapturePoint->setEnabled( false );

    mActionCaptureLine->setEnabled( false );

    mActionCapturePolygon->setEnabled( false );

    mActionAddIsland->setEnabled( false );

#if 0 //these three tools to be deprecated - use node tool rather

    mActionAddVertex->setEnabled( false );

    mActionDeleteVertex->setEnabled( false );

    mActionMoveVertex->setEnabled( false );

#endif

    QAction *actionCapturePoint() { return mActionCapturePoint; }

    QAction *actionCaptureLine() { return mActionCaptureLine; }

    QAction *actionCapturePolygon() { return mActionCapturePolygon; }

    QAction *actionAddIsland() { return mActionAddIsland; }

    //! activates the capture point tool

    void capturePoint();

    //! activates the capture line tool

    void captureLine();

    //! activates the capture polygon tool

    void capturePolygon();

    //! activates the add vertex tool

    void addVertex();

    //! activates the move vertex tool

    void moveVertex();

    //! activates the delete vertex tool

    void deleteVertex();

    //! activates the add island tool

    void addIsland();

        QgsMapTool* mCapturePoint;

        QgsMapTool* mCaptureLine;

        QgsMapTool* mCapturePolygon;

        QgsMapTool* mAddIsland;

    //! Popup menu for the capture tools

    QMenu *toolPopupCapture;

QAction *QgisAppInterface::actionCapturePoint() { return qgis->actionCapturePoint(); }

QAction *QgisAppInterface::actionCaptureLine() { return qgis->actionCaptureLine(); }

QAction *QgisAppInterface::actionCapturePolygon() { return qgis->actionCapturePolygon(); }

QAction *QgisAppInterface::actionAddIsland() { return qgis->actionAddIsland(); }

    virtual QAction *actionCapturePoint();

    virtual QAction *actionCaptureLine();

    virtual QAction *actionCapturePolygon();

    virtual QAction *actionAddIsland();

QgsMapToolAddFeature::QgsMapToolAddFeature( QgsMapCanvas* canvas, CaptureMode tool ): QgsMapToolCapture( canvas, tool )

    // emit signal - QgisApp can catch it and save point position to clipboard

    // FIXME: is this still actual or something old that's not used anymore?

    //emit xyClickCoordinates(idPoint);

      int size = 0;

      char endian = QgsApplication::endian();

      unsigned char *wkb = NULL;

      int wkbtype = 0;

      double x = savePoint.x();

      double y = savePoint.y();

        size = 1 + sizeof( int ) + 2 * sizeof( double );

        wkb = new unsigned char[size];

        wkbtype = QGis::WKBPoint;

        memcpy( &wkb[0], &endian, 1 );

        memcpy( &wkb[1], &wkbtype, sizeof( int ) );

        memcpy( &wkb[5], &x, sizeof( double ) );

        memcpy( &wkb[5] + sizeof( double ), &y, sizeof( double ) );

        size = 2 + 3 * sizeof( int ) + 2 * sizeof( double );

        wkb = new unsigned char[size];

        wkbtype = QGis::WKBMultiPoint;

        int position = 0;

        memcpy( &wkb[position], &endian, 1 );

        position += 1;

        memcpy( &wkb[position], &wkbtype, sizeof( int ) );

        position += sizeof( int );

        int npoint = 1;

        memcpy( &wkb[position], &npoint, sizeof( int ) );

        position += sizeof( int );

        memcpy( &wkb[position], &endian, 1 );

        position += 1;

        int pointtype = QGis::WKBPoint;

        memcpy( &wkb[position], &pointtype, sizeof( int ) );

        position += sizeof( int );

        memcpy( &wkb[position], &x, sizeof( double ) );

        position += sizeof( double );

        memcpy( &wkb[position], &y, sizeof( double ) );

      f->setGeometryAndOwnership( &wkb[0], size );

      unsigned char* wkb;

      int wkbsize;

      char endian = QgsApplication::endian();

          wkbsize = 1 + 2 * sizeof( int ) + 2 * size() * sizeof( double );

          wkb = new unsigned char[wkbsize];

          int wkbtype = QGis::WKBLineString;

          int length = size();

          memcpy( &wkb[0], &endian, 1 );

          memcpy( &wkb[1], &wkbtype, sizeof( int ) );

          memcpy( &wkb[1+sizeof( int )], &length, sizeof( int ) );

          int position = 1 + 2 * sizeof( int );

          double x, y;

          for ( QList<QgsPoint>::iterator it = begin(); it != end(); ++it )

          {

            QgsPoint savePoint = *it;

            x = savePoint.x();

            y = savePoint.y();

            memcpy( &wkb[position], &x, sizeof( double ) );

            position += sizeof( double );

            memcpy( &wkb[position], &y, sizeof( double ) );

            position += sizeof( double );

          }

          wkbsize = 1 + 2 * sizeof( int ) + 1 + 2 * sizeof( int ) + 2 * size() * sizeof( double );

          wkb = new unsigned char[wkbsize];

          int position = 0;

          int wkbtype = QGis::WKBMultiLineString;

          memcpy( &wkb[position], &endian, 1 );

          position += 1;

          memcpy( &wkb[position], &wkbtype, sizeof( int ) );

          position += sizeof( int );

          int nlines = 1;

          memcpy( &wkb[position], &nlines, sizeof( int ) );

          position += sizeof( int );

          memcpy( &wkb[position], &endian, 1 );

          position += 1;

          int linewkbtype = QGis::WKBLineString;

          memcpy( &wkb[position], &linewkbtype, sizeof( int ) );

          position += sizeof( int );

          int length = size();

          memcpy( &wkb[position], &length, sizeof( int ) );

          position += sizeof( int );

          double x, y;

          for ( QList<QgsPoint>::iterator it = begin(); it != end(); ++it )

          {

            QgsPoint savePoint = *it;

            x = savePoint.x();

            y = savePoint.y();

            memcpy( &wkb[position], &x, sizeof( double ) );

            position += sizeof( double );

            memcpy( &wkb[position], &y, sizeof( double ) );

            position += sizeof( double );

          }

        f->setGeometryAndOwnership( &wkb[0], wkbsize );

          wkbsize = 1 + 3 * sizeof( int ) + 2 * ( size() + 1 ) * sizeof( double );

          wkb = new unsigned char[wkbsize];

          int wkbtype = QGis::WKBPolygon;

          int length = size() + 1;//+1 because the first point is needed twice

          int numrings = 1;

          memcpy( &wkb[0], &endian, 1 );

          memcpy( &wkb[1], &wkbtype, sizeof( int ) );

          memcpy( &wkb[1+sizeof( int )], &numrings, sizeof( int ) );

          memcpy( &wkb[1+2*sizeof( int )], &length, sizeof( int ) );

          int position = 1 + 3 * sizeof( int );

          double x, y;

          QList<QgsPoint>::iterator it;

          for ( it = begin(); it != end(); ++it )

          {

            QgsPoint savePoint = *it;

            x = savePoint.x();

            y = savePoint.y();

            memcpy( &wkb[position], &x, sizeof( double ) );

            position += sizeof( double );

            memcpy( &wkb[position], &y, sizeof( double ) );

            position += sizeof( double );

          }

          // close the polygon

          it = begin();

          QgsPoint savePoint = *it;

          x = savePoint.x();

          y = savePoint.y();

          memcpy( &wkb[position], &x, sizeof( double ) );

          position += sizeof( double );

          memcpy( &wkb[position], &y, sizeof( double ) );

          wkbsize = 2 + 5 * sizeof( int ) + 2 * ( size() + 1 ) * sizeof( double );

          wkb = new unsigned char[wkbsize];

          int wkbtype = QGis::WKBMultiPolygon;

          int polygontype = QGis::WKBPolygon;

          int length = size() + 1;//+1 because the first point is needed twice

          int numrings = 1;

          int numpolygons = 1;

          int position = 0; //pointer position relative to &wkb[0]

          memcpy( &wkb[position], &endian, 1 );

          position += 1;

          memcpy( &wkb[position], &wkbtype, sizeof( int ) );

          position += sizeof( int );

          memcpy( &wkb[position], &numpolygons, sizeof( int ) );

          position += sizeof( int );

          memcpy( &wkb[position], &endian, 1 );

          position += 1;

          memcpy( &wkb[position], &polygontype, sizeof( int ) );

          position += sizeof( int );

          memcpy( &wkb[position], &numrings, sizeof( int ) );

          position += sizeof( int );

          memcpy( &wkb[position], &length, sizeof( int ) );

          position += sizeof( int );

          double x, y;

          QList<QgsPoint>::iterator it;

          for ( it = begin(); it != end(); ++it ) //add the captured points to the polygon

          {

            QgsPoint savePoint = *it;

            x = savePoint.x();

            y = savePoint.y();

            memcpy( &wkb[position], &x, sizeof( double ) );

            position += sizeof( double );

            memcpy( &wkb[position], &y, sizeof( double ) );

            position += sizeof( double );

          }

          // close the polygon

          it = begin();

          QgsPoint savePoint = *it;

          x = savePoint.x();

          y = savePoint.y();

          memcpy( &wkb[position], &x, sizeof( double ) );

          position += sizeof( double );

          memcpy( &wkb[position], &y, sizeof( double ) );

        f->setGeometryAndOwnership( &wkb[0], wkbsize );

    QgsMapToolAddFeature( QgsMapCanvas* canvas, CaptureMode mode );

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

    qgsmaptooladdisland.cpp  - map tool to add new polygons to multipolygon features

    -----------------------

    begin                : Mai 2007

    copyright            : (C) 2007 by Marco Hugentobler

    email                : marco dot hugentobler at karto dot baug dot ethz dot ch

 ***************************************************************************

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

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

/* $Id$ */

#include "qgsmaptooladdisland.h"

#include "qgsgeometry.h"

#include "qgsmapcanvas.h"

#include "qgsproject.h"

#include "qgsrubberband.h"

#include "qgsvectorlayer.h"

#include <QMessageBox>

#include <QMouseEvent>

QgsMapToolAddIsland::QgsMapToolAddIsland( QgsMapCanvas* canvas ): QgsMapToolCapture( canvas, QgsMapToolCapture::CapturePolygon )

{

}

QgsMapToolAddIsland::~QgsMapToolAddIsland()

{

}

void QgsMapToolAddIsland::canvasReleaseEvent( QMouseEvent * e )

{

  //check if we operate on a vector layer

  QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() );

  if ( !vlayer )

  {

    QMessageBox::information( 0,

                              tr( "Not a vector layer" ),

                              tr( "The current layer is not a vector layer" ) );

    return;

  }

  if ( !vlayer->isEditable() )

  {

    QMessageBox::information( 0,

                              tr( "Layer not editable" ),

                              tr( "Cannot edit the vector layer. Use 'Toggle Editing' to make it editable." )

                            );

    return;

  }

  //inform user at the begin of the digitising action that the island tool only works if exactly one feature is selected

  int nSelectedFeatures = vlayer->selectedFeatureCount();

  QString selectionErrorMsg;

  if ( nSelectedFeatures < 1 )

  {

    selectionErrorMsg = tr( "No feature selected. Please select a feature with the selection tool or in the attribute table" );

  }

  else if ( nSelectedFeatures > 1 )

  {

    selectionErrorMsg = tr( "Several features are selected. Please select only one feature to which an island should be added." );

  }

  if ( !selectionErrorMsg.isEmpty() )

  {

    QMessageBox::critical( 0, tr( "Error, could not add island" ), selectionErrorMsg );

    stopCapturing();

    return;

  }

  //add point to list and to rubber band

  int error = addVertex( e->pos() );

  if ( error == 1 )

  {

    //current layer is not a vector layer

    return;

  }

  else if ( error == 2 )

  {

    //problem with coordinate transformation

    QMessageBox::information( 0,

                              tr( "Coordinate transform error" ),

                              tr( "Cannot transform the point to the layers coordinate system" ) );

    return;

  }

  if ( e->button() == Qt::LeftButton )

  {

    startCapturing();

  }

  else if ( e->button() == Qt::RightButton )

  {

    //close polygon

    closePolygon();

    vlayer->beginEditCommand( tr( "Part added" ) );

    int errorCode = vlayer->addIsland( points() );

    QString errorMessage;

    if ( errorCode != 0 )

    {

      if ( errorCode == 1 )

      {

        errorMessage = tr( "Selected feature is not a multipolygon" );

      }

      else if ( errorCode == 2 )

      {

        errorMessage = tr( "New ring is not a valid geometry" );

      }

      else if ( errorCode == 3 )

      {

        errorMessage = tr( "New polygon ring not disjoint with existing polygons" );

      }

      else if ( errorCode == 4 )

      {

        errorMessage = tr( "No feature selected. Please select a feature with the selection tool or in the attribute table" );

      }

      else if ( errorCode == 5 )

      {

        errorMessage = tr( "Several features are selected. Please select only one feature to which an island should be added." );

      }

      else if ( errorCode == 6 )

      {

        errorMessage = tr( "Selected geometry could not be found" );

      }

      QMessageBox::critical( 0, tr( "Error, could not add island" ), errorMessage );

      vlayer->destroyEditCommand();

    }

    else

    {

      //add points to other features to keep topology up-to-date

      int topologicalEditing = QgsProject::instance()->readNumEntry( "Digitizing", "/TopologicalEditing", 0 );

      if ( topologicalEditing )

      {

        addTopologicalPoints( points() );

      }

      vlayer->endEditCommand();

    }

    stopCapturing();

  }

}

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

    qgsmaptooladdisland.h  - map tool to add new polygons to multipolygon features

    ---------------------

    begin                : Mai 2007

    copyright            : (C) 2007 by Marco Hugentobler

    email                : marco dot hugentobler at karto dot baug dot ethz dot ch

 ***************************************************************************

 *                                                                         *

 *   This program is free software; you can redistribute it and/or modify  *

 *   it under the terms of the GNU General Public License as published by  *

 *   the Free Software Foundation; either version 2 of the License, or     *

 *   (at your option) any later version.                                   *

 *                                                                         *

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

/* $Id$ */

#include "qgsmaptoolcapture.h"

/**A map tool that adds new polygons to multipolygon features*/

class QgsMapToolAddIsland: public QgsMapToolCapture

{

    Q_OBJECT

  public:

    QgsMapToolAddIsland( QgsMapCanvas* canvas );

    virtual ~QgsMapToolAddIsland();

    void canvasReleaseEvent( QMouseEvent * e );

};