qgsgrassedit.cpp

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

/***************************************************************************
    qgsgrassselect.cpp  -  Select GRASS layer dialog
                             -------------------
    begin                : March, 2004
    copyright            : (C) 2004 by Radim Blazek
    email                : [e-mail]
 ***************************************************************************/
/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
#include <iostream>

//#include <qnamespace.h>
#include <QtGlobal>
#include <QColorDialog>
#include <Q3ListBox>
#include <Q3ListView>
#include <Q3PointArray>
#include <Q3Table>
#include <QAction>
#include <QActionGroup>
#include <QCloseEvent>
#include <QComboBox>
#include <QCursor>
#include <QDir>
#include <QEvent>
#include <QFile>
#include <QInputDialog>
#include <QLabel>
#include <QMessageBox>
#include <QPainter>
#include <QPen>
#include <QPixmap>
#include <QSettings>
#include <QSpinBox>
#include <QStatusBar>
#include <QStringList>
#include <QToolBar>


#include "qgis.h"
#include "qgisinterface.h"
#include "qgsapplication.h"
#include "qgscsexception.h"
#include "qgsmapcanvas.h"
#include "qgsmapcanvasitem.h"
#include "qgsmaplayer.h"
#include "qgsmaprender.h"
#include "qgsvectorlayer.h"
#include "qgsdataprovider.h"
#include "qgsmaptoolpan.h"
#include "qgsmaptopixel.h"
#include "qgsfield.h"
#include "qgsvertexmarker.h"
#include "qgsrubberband.h"
#include "qgsproject.h"
#include "qgslogger.h"

extern "C" {
#include <grass/gis.h>
#include <grass/Vect.h>
}

#include "../../src/providers/grass/qgsgrass.h"
#include "../../src/providers/grass/qgsgrassprovider.h"
#include "qgsgrassattributes.h"
#include "qgsgrassedit.h"
#include "qgsgrassedittools.h"
#include "qgsgrassutils.h"

#ifdef _MSC_VER
#define round(x)  ((x) >= 0 ? floor((x)+0.5) : floor((x)-0.5))
#endif


class QgsGrassEditLayer : public QgsMapCanvasItem
{
public:

  QgsGrassEditLayer(QgsMapCanvas* mapCanvas):QgsMapCanvasItem(mapCanvas)
  {
  }

  virtual void paint(QPainter* p)
  {
    p->drawPixmap(0,0, mPixmap);
  }

  virtual QRectF boundingRect() const
  {
    return QRectF(0,0, mMapCanvas->width(), mMapCanvas->height());
  }

  virtual void updatePosition()
  {
    setPos(QPointF(mPanningOffset));
  }

  QPixmap& pixmap() { return mPixmap; }

private:

  QPixmap mPixmap;
};



bool QgsGrassEdit::mRunning = false;

QgsGrassEdit::QgsGrassEdit ( QgisInterface *iface, QgsMapLayer* layer, bool newMap,
    QWidget * parent, Qt::WFlags f )
    : QMainWindow(parent,f), QgsGrassEditBase (), mInited(false), 
      mMapTool(0), mCanvasEdit(0), mRubberBandLine(0), mRubberBandIcon(0)
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit()" << std::endl;
#endif

  setupUi(this);

  mRunning = true;
  mValid = false;
  mTool = QgsGrassEdit::NONE;
  mSuspend = false;
  mIface = iface;
  mNewMap = newMap;

  mProjectionEnabled = (QgsProject::instance()->readNumEntry("SpatialRefSys","/ProjectionsEnabled",0)!=0);

  mCanvas = mIface->getMapCanvas();

  if ( !isEditable(layer) ) return;

  //TODO dynamic_cast ?
  mLayer = (QgsVectorLayer*)layer;

  //TODO dynamic_cast ?
  mProvider = (QgsGrassProvider *) mLayer->getDataProvider();

  init();

}

bool QgsGrassEdit::isEditable ( QgsMapLayer *layer )
{
  if ( !layer ) return false;

  QgsDebugMsg("layer name: " + layer->name());

  if ( layer->type() != QgsMapLayer::VECTOR ) {
    QgsDebugMsg("The selected layer is not vector.");
    return false;
  }

  //TODO dynamic_cast ?
  QgsVectorLayer *vector = (QgsVectorLayer*)layer;

  QgsDebugMsg("Vector layer type: " + vector->providerType());

  if ( vector->providerType() != "grass" ) {
    QgsDebugMsg("The selected layer is not GRASS.");
    return false;
  }

  return true;
}

void QgsGrassEdit::keyPress(QKeyEvent *e) 
{
  std::cerr << "QgsGrassEdit::keyPress" << std::endl;
  // This does not work:
  //keyPressEvent(e); 

  // TODO: this is not optimal
  switch ( e->key() )
  {
  case Qt::Key_F1: newPoint(); break;  
  case Qt::Key_F2: newLine(); break;  
  case Qt::Key_F3: newBoundary(); break;  
  case Qt::Key_F4: newCentroid(); break;  
  case Qt::Key_F5: moveVertex(); break;  
  case Qt::Key_F6: addVertex(); break;  
  case Qt::Key_F7: deleteVertex(); break;  
  case Qt::Key_F9: moveLine(); break;  
  case Qt::Key_F10: splitLine(); break;  
  case Qt::Key_F11: deleteLine(); break;  
  default: break;
  }
}


void QgsGrassEdit::init()
{
  if ( !(mProvider->isGrassEditable()) ) {
    QMessageBox::warning( 0, tr("Warning"), tr("You are not owner of the mapset, "
      "cannot open the vector for editing.") );
    return;
  }

  if ( !(mProvider->startEdit()) ) {
    QMessageBox::warning( 0, tr("Warning"), tr("Cannot open vector for update." ));
    return;
  }

  connect ( mCanvas, SIGNAL(keyPressed(QKeyEvent *)), this, SLOT(keyPress(QKeyEvent *)) );

  QString myIconPath = QgsApplication::themePath() + "/grass/";

  mToolBar = addToolBar(tr("Edit tools"));

  mNewPointAction = new QAction(
    QIcon(myIconPath+"grass_new_point.png"), tr("New point"), this);
  mNewPointAction->setShortcut ( QKeySequence(Qt::Key_F1) ); 
  mToolBar->addAction ( mNewPointAction );
  connect ( mNewPointAction, SIGNAL(triggered()), this, SLOT(newPoint()) );

  mNewLineAction = new QAction(
    QIcon(myIconPath+"grass_new_line.png"), tr("New line"), this);
  mNewLineAction->setShortcut ( QKeySequence(Qt::Key_F2) ); 
  mToolBar->addAction ( mNewLineAction );
  connect ( mNewLineAction, SIGNAL(triggered()), this, SLOT(newLine()) );

  mNewBoundaryAction = new QAction(
    QIcon(myIconPath+"grass_new_boundary.png"), tr("New boundary"), this);
  mNewBoundaryAction->setShortcut ( QKeySequence(Qt::Key_F3) ); 
  mToolBar->addAction ( mNewBoundaryAction );
  connect ( mNewBoundaryAction, SIGNAL(triggered()), this, SLOT(newBoundary()) );

  mNewCentroidAction = new QAction(
    QIcon(myIconPath+"grass_new_centroid.png"), tr("New centroid"), this);
  mNewCentroidAction->setShortcut ( QKeySequence(Qt::Key_F4) ); 
  mToolBar->addAction ( mNewCentroidAction );
  connect ( mNewCentroidAction, SIGNAL(triggered()), this, SLOT(newCentroid()) );

  mMoveVertexAction = new QAction(
    QIcon(myIconPath+"grass_move_vertex.png"), tr("Move vertex"), this);
  mMoveVertexAction->setShortcut ( QKeySequence(Qt::Key_F5) ); 
  mToolBar->addAction ( mMoveVertexAction );
  connect ( mMoveVertexAction, SIGNAL(triggered()), this, SLOT(moveVertex()) );

  mAddVertexAction = new QAction(
    QIcon(myIconPath+"grass_add_vertex.png"), tr("Add vertex"), this);
  mAddVertexAction->setShortcut ( QKeySequence(Qt::Key_F6) ); 
  mToolBar->addAction ( mAddVertexAction );
  connect ( mAddVertexAction, SIGNAL(triggered()), this, SLOT(addVertex()) );

  mDeleteVertexAction = new QAction(
    QIcon(myIconPath+"grass_delete_vertex.png"), tr("Delete vertex"), this);
  mDeleteVertexAction->setShortcut ( QKeySequence(Qt::Key_F7) ); 
  mToolBar->addAction ( mDeleteVertexAction );
  connect ( mDeleteVertexAction, SIGNAL(triggered()), this, SLOT(deleteVertex()) );

  mMoveLineAction = new QAction(
    QIcon(myIconPath+"grass_move_line.png"), tr("Move element"), this);
  mMoveLineAction->setShortcut ( QKeySequence(Qt::Key_F9) ); 
  mToolBar->addAction ( mMoveLineAction );
  connect ( mMoveLineAction, SIGNAL(triggered()), this, SLOT(moveLine()) );

  mSplitLineAction = new QAction(
    QIcon(myIconPath+"grass_split_line.png"), tr("Split line"), this);
  mSplitLineAction->setShortcut ( QKeySequence(Qt::Key_F10) ); 
  mToolBar->addAction ( mSplitLineAction );
  connect ( mSplitLineAction, SIGNAL(triggered()), this, SLOT(splitLine()) );

  mDeleteLineAction = new QAction(
    QIcon(myIconPath+"grass_delete_line.png"), tr("Delete element"), this);
  mDeleteLineAction->setShortcut ( QKeySequence(Qt::Key_F11) ); 
  mToolBar->addAction ( mDeleteLineAction );
  connect ( mDeleteLineAction, SIGNAL(triggered()), this, SLOT(deleteLine()) );

  mEditAttributesAction = new QAction(
    QIcon(myIconPath+"grass_edit_attributes.png"), tr("Edit attributes"), this);
  mToolBar->addAction ( mEditAttributesAction );
  connect ( mEditAttributesAction, SIGNAL(triggered()), this, SLOT(editAttributes()) );

  mCloseEditAction = new QAction(
    QIcon(myIconPath+"grass_close_edit.png"), tr("Close"), this);
  mToolBar->addAction ( mCloseEditAction );
  connect ( mCloseEditAction, SIGNAL(triggered()), this, SLOT(closeEdit()) );

  mNewPointAction->setCheckable ( true );
  mNewLineAction->setCheckable ( true );
  mNewBoundaryAction->setCheckable ( true );
  mNewCentroidAction->setCheckable ( true );
  mMoveVertexAction->setCheckable ( true );
  mAddVertexAction->setCheckable ( true );
  mDeleteVertexAction->setCheckable ( true );
  mMoveLineAction->setCheckable ( true );
  mSplitLineAction->setCheckable ( true );
  mDeleteLineAction->setCheckable ( true );
  mEditAttributesAction->setCheckable ( true );

  QActionGroup *ag = new QActionGroup ( this );
  ag->addAction ( mNewPointAction );
  ag->addAction ( mNewLineAction );
  ag->addAction ( mNewBoundaryAction );
  ag->addAction ( mNewCentroidAction );
  ag->addAction ( mMoveVertexAction );
  ag->addAction ( mAddVertexAction );
  ag->addAction ( mDeleteVertexAction );
  ag->addAction ( mMoveLineAction );
  ag->addAction ( mSplitLineAction );
  ag->addAction ( mDeleteLineAction );
  ag->addAction ( mEditAttributesAction );

  mEditPoints = Vect_new_line_struct ();
  mPoints = Vect_new_line_struct ();
  mCats = Vect_new_cats_struct ();

  // Set lines symbology from map
  int nlines = mProvider->numLines(); 
  mLineSymb.resize(nlines+1000);
  for ( int line = 1; line <= nlines; line++ ) {
    mLineSymb[line] = lineSymbFromMap ( line );
  }

  // Set nodes symbology from map
  int nnodes = mProvider->numNodes(); 
  mNodeSymb.resize(nnodes+1000); 
  for ( int node = 1; node <= nnodes; node++ ) {
    mNodeSymb[node] = nodeSymbFromMap ( node );
  }

  // Set default colors
  mSymb.resize(SYMB_COUNT);
  mSymb[SYMB_BACKGROUND].setColor    ( QColor ( 255, 255, 255 ) );  // white
  mSymb[SYMB_HIGHLIGHT].setColor     ( QColor ( 255, 255,   0 ) );  // yellow
  mSymb[SYMB_DYNAMIC].setColor       ( QColor ( 125, 125, 125 ) );  // grey
  mSymb[SYMB_POINT].setColor         ( QColor (   0,   0,   0 ) );  // black
  mSymb[SYMB_LINE].setColor          ( QColor (   0,   0,   0 ) );  // black
  mSymb[SYMB_BOUNDARY_0].setColor    ( QColor ( 255,   0,   0 ) );  // red
  mSymb[SYMB_BOUNDARY_1].setColor    ( QColor ( 255, 125,   0 ) );  // orange
  mSymb[SYMB_BOUNDARY_2].setColor    ( QColor (   0, 255,   0 ) );  // green
  mSymb[SYMB_CENTROID_IN].setColor   ( QColor (   0, 255,   0 ) );  // green
  mSymb[SYMB_CENTROID_OUT].setColor  ( QColor ( 255,   0,   0 ) );  // red
  mSymb[SYMB_CENTROID_DUPL].setColor ( QColor ( 255,   0, 255 ) );  // magenta
  mSymb[SYMB_NODE_1].setColor        ( QColor ( 255,   0,   0 ) );  // red
  mSymb[SYMB_NODE_2].setColor        ( QColor (   0, 255,   0 ) );  // green

  // Set mSymbDisplay
  mSymbDisplay.resize(SYMB_COUNT);
  mSymbDisplay[SYMB_BACKGROUND] = true;
  mSymbDisplay[SYMB_HIGHLIGHT] = true;
  mSymbDisplay[SYMB_DYNAMIC] = true;
  mSymbDisplay[SYMB_POINT] = true;
  mSymbDisplay[SYMB_LINE] = true;
  mSymbDisplay[SYMB_BOUNDARY_0] = true;
  mSymbDisplay[SYMB_BOUNDARY_1] = true;
  mSymbDisplay[SYMB_BOUNDARY_2] = true;
  mSymbDisplay[SYMB_CENTROID_IN] = true;
  mSymbDisplay[SYMB_CENTROID_OUT] = true;
  mSymbDisplay[SYMB_CENTROID_DUPL] = true;
  mSymbDisplay[SYMB_NODE_1] = true;
  mSymbDisplay[SYMB_NODE_2] = true;

  // Set symbology names
  mSymbName.resize(SYMB_COUNT);
  mSymbName[SYMB_BACKGROUND]    = tr("Background");
  mSymbName[SYMB_HIGHLIGHT]     = tr("Highlight");
  mSymbName[SYMB_DYNAMIC]       = tr("Dynamic");
  mSymbName[SYMB_POINT]         = tr("Point");
  mSymbName[SYMB_LINE]          = tr("Line");
  mSymbName[SYMB_BOUNDARY_0]    = tr("Boundary (no area)");
  mSymbName[SYMB_BOUNDARY_1]    = tr("Boundary (1 area)");
  mSymbName[SYMB_BOUNDARY_2]    = tr("Boundary (2 areas)");
  mSymbName[SYMB_CENTROID_IN]   = tr("Centroid (in area)");
  mSymbName[SYMB_CENTROID_OUT]  = tr("Centroid (outside area)");
  mSymbName[SYMB_CENTROID_DUPL] = tr("Centroid (duplicate in area)");
  mSymbName[SYMB_NODE_1]        = tr("Node (1 line)");
  mSymbName[SYMB_NODE_2]        = tr("Node (2 lines)");

  // Restore symbology
  QString spath = "/GRASS/edit/symb/";
  QSettings settings;

  mLineWidth = settings.readNumEntry (
    spath + "lineWidth", 1 );
  mSize = settings.readNumEntry (
    spath + "markerSize", 9 );
  mLineWidthSpinBox->setValue(mLineWidth);
  mMarkerSizeSpinBox->setValue(mSize);

  for ( int i = 0; i < SYMB_COUNT; i++ ) {
    bool ok;
    bool displ = settings.readBoolEntry ( 
      spath + "display/" + QString::number(i), 
      true, &ok );
    if ( ok ) {
      mSymbDisplay[i] = displ;
    }

    QString colorName = settings.readEntry (
      spath + "color/" + QString::number(i), 
      "", &ok );
    if ( ok ) {
      QColor color( colorName );
      mSymb[i].setColor( color );
    }
    mSymb[i].setWidth( mLineWidth );
  }

  // Set Symbology in dialog
  symbologyList->setColumnText(0,tr("Disp","Column title") );
  symbologyList->setColumnWidth(0,20);
  symbologyList->addColumn( tr("Color","Column title") );
  symbologyList->setColumnWidth(0,50);
  symbologyList->addColumn( tr("Type","Column title") );
  symbologyList->setColumnWidthMode(2,Q3ListView::Maximum);
  symbologyList->addColumn(tr("Index","Column title") , 0);
  symbologyList->clear();
  symbologyList->setSorting(-1);

  for ( int i = SYMB_COUNT-1; i >= 0; i-- ) {
    if ( i == SYMB_NODE_0 ) continue;

    QPixmap pm ( 40, 15 );
    pm.fill( mSymb[i].color() );
    QString index;
    index.sprintf ("%d", i );

    if ( i == SYMB_BACKGROUND || i == SYMB_HIGHLIGHT || i == SYMB_DYNAMIC ) { 
      Q3ListViewItem *lvi = new Q3ListViewItem ( symbologyList , "", "", mSymbName[i] );
      lvi->setPixmap ( 1, pm );
      lvi->setText ( 3, index );
    } else {
      Q3CheckListItem *clvi = new Q3CheckListItem ( symbologyList , "", Q3CheckListItem::CheckBox );
      clvi->setText ( 2, mSymbName[i] );
      clvi->setPixmap ( 1, pm );
      clvi->setOn ( mSymbDisplay[i] );
      clvi->setText ( 3, index );
    }
  }

  connect( symbologyList, SIGNAL(pressed(Q3ListViewItem *, const QPoint &, int)), 
    this, SLOT(changeSymbology(Q3ListViewItem *, const QPoint &, int)));

  // Init table tab
  mAttributeTable->setLeftMargin(0); // hide row labels
  mAttributeTable->horizontalHeader()->setLabel( 0, tr("Column") );
  mAttributeTable->horizontalHeader()->setLabel( 1, tr("Type") );
  mAttributeTable->horizontalHeader()->setLabel( 2, tr("Length") );

  int ndblinks = mProvider->numDbLinks();

  if ( ndblinks > 0 ) {
    for ( int i = 0; i < ndblinks; i++ ) {
      int f = mProvider->dbLinkField ( i ); 

      QString str;
      str.sprintf ( "%d", f );  
      mTableField->insertItem ( str );
      mFieldBox->insertItem( str );
      if ( i == 0 ) {