qgsgrassedit.cpp

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

        setAttributeTable( f );
      }
    }
    mTableField->setCurrentItem ( 0 ); 
    mFieldBox->setCurrentItem ( 0 );
  } else { 
    mTableField->insertItem ( "1" );
    setAttributeTable ( 1 );

    mFieldBox->insertItem("1");
  }

  connect( mAttributeTable, SIGNAL(valueChanged(int,int)), this, SLOT(columnTypeChanged(int,int)) );

  // Set variables
  mSelectedLine = 0;
  mAttributes = 0;

  // Read max cats
  for (int i = 0; i < mProvider->cidxGetNumFields(); i++ ) {
    int field = mProvider->cidxGetFieldNumber(i);
    if ( field > 0 ) {
      int cat = mProvider->cidxGetMaxCat(i);
      MaxCat mc;
      mc.field = field;
      mc.maxCat = cat;
      mMaxCats.push_back(mc);
    }
  }

  connect( mCanvas, SIGNAL(renderComplete(QPainter *)), this, SLOT(postRender(QPainter *)));

  mCanvasEdit = new QgsGrassEditLayer(mCanvas);

  mPixmap = &mCanvasEdit->pixmap();

  mRubberBandLine = new QgsRubberBand(mCanvas);
  mRubberBandIcon = new QgsVertexMarker(mCanvas);
  mRubberBandLine->setZValue(20);
  mRubberBandIcon->setZValue(20);

  // Init GUI values
  mCatModeBox->insertItem( tr("Next not used"), CAT_MODE_NEXT );
  mCatModeBox->insertItem( tr("Manual entry"), CAT_MODE_MANUAL );
  mCatModeBox->insertItem( tr("No category"), CAT_MODE_NOCAT );
  catModeChanged ( );

  // TODO: how to get keyboard events from canvas (shortcuts)

  restorePosition();

  mValid = true; 
  mInited = true; 
}

void QgsGrassEdit::attributeTableFieldChanged ( void )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::attributeTableFieldChanged" << std::endl;
#endif
  int field = mTableField->currentText().toInt();

  setAttributeTable ( field );
}

void QgsGrassEdit::setAttributeTable ( int field )
{
  mAttributeTable->setNumRows ( 0 );

  QString *key = mProvider->key ( field );

  if ( !key->isEmpty() ) { // Database link defined
    std::vector<QgsField> *cols = mProvider->columns ( field );

    mAttributeTable->setNumRows ( cols->size() );


    for ( unsigned int c = 0; c < cols->size(); c++ ) {
      QgsField col = (*cols)[c];

      Q3TableItem *ti;

      ti = new Q3TableItem( mAttributeTable, Q3TableItem::Never, col.name() );
      ti->setEnabled( false );
      mAttributeTable->setItem ( c, 0, ti );

      ti = new Q3TableItem( mAttributeTable, Q3TableItem::Never, col.typeName() );
      ti->setEnabled( false );
      mAttributeTable->setItem ( c, 1, ti );

      QString str;
      str.sprintf("%d", col.length() );
      ti = new Q3TableItem( mAttributeTable, Q3TableItem::Never, str );
      ti->setEnabled( false );
      mAttributeTable->setItem ( c, 2, ti );
    }
  } else {
    mAttributeTable->setNumRows ( 1 );

    Q3TableItem *ti;

    ti = new Q3TableItem( mAttributeTable, Q3TableItem::Always, "cat" );
    mAttributeTable->setItem ( 0, 0, ti );

    ti = new Q3TableItem( mAttributeTable, Q3TableItem::Never, "integer" );
    ti->setEnabled( false );
    mAttributeTable->setItem ( 0, 1, ti );

    ti = new Q3TableItem( mAttributeTable, Q3TableItem::Never, "" );
    ti->setEnabled( false );
    mAttributeTable->setItem ( 0, 2, ti );
  }
}

void QgsGrassEdit::addColumn ( void )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::addColumn()" << std::endl;
#endif
  int r = mAttributeTable->numRows();
  mAttributeTable->setNumRows( r+1 );
  mAttributeTable->setRowReadOnly ( r, false );

  QString cn;
  cn.sprintf ( "column%d", r+1 );

  Q3TableItem *ti;

  ti = new Q3TableItem( mAttributeTable, Q3TableItem::Always, cn );
  mAttributeTable->setItem ( r, 0, ti );

  QStringList types;
  types.push_back ( "integer" );
  types.push_back ( "double precision" );
  types.push_back ( "varchar" );

  Q3ComboTableItem *cti = new Q3ComboTableItem ( mAttributeTable, types ); 
  cti->setCurrentItem(0);
  mAttributeTable->setItem ( r, 1, cti );

  ti = new Q3TableItem( mAttributeTable, Q3TableItem::Never, "20" );
  ti->setEnabled(false);
  mAttributeTable->setItem ( r, 2, ti );
}

void QgsGrassEdit::columnTypeChanged ( int row, int col )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::columnChanged() row = " << row << " col = " << col << std::endl;
#endif

  if ( col != 1 ) return;

  Q3ComboTableItem *cti = (Q3ComboTableItem *) mAttributeTable->item ( row, 1 ); 

  Q3TableItem *ti = mAttributeTable->item ( row, 2 );

  if ( cti->currentText().compare( "varchar" ) != 0 ) {
    Q3TableItem *nti = new Q3TableItem( mAttributeTable, Q3TableItem::Never, ti->text() );
    nti->setEnabled(false);
    mAttributeTable->setItem ( row, 2, nti );
    //delete ti;
  } else {
    Q3TableItem *nti = new Q3TableItem( mAttributeTable, Q3TableItem::Always, ti->text() );
    nti->setEnabled(true);
    mAttributeTable->setItem ( row, 2, nti );
    //delete ti;
  }
  mAttributeTable->updateCell ( row, 2 );
}

void QgsGrassEdit::alterTable ( void )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::alterTable()" << std::endl;
#endif

  // Create new table if first column name is editable otherwise alter table
  int field = mTableField->currentText().toInt();

  Q3TableItem *ti;
  ti = mAttributeTable->item ( 0, 0 );

  QString sql;

  if ( mAttributeTable->item(0,0)->isEnabled() ) {
#ifdef QGISDEBUG
    std::cerr << "Create new table" << std::endl;
#endif

    for ( int i = 0; i < mAttributeTable->numRows(); i++ ) {
      if ( i > 0 ) sql.append(", " );


      sql.append ( mAttributeTable->item(i,0)->text() + " " + mAttributeTable->item(i,1)->text() );

      if ( mAttributeTable->item(i,1)->text().compare("varchar") == 0 ) {
        sql.append ( " (" + mAttributeTable->item(i,2)->text() + ")" );
      }
    }

    QString *error = mProvider->createTable ( field, mAttributeTable->item(0,0)->text(), sql );  

    if ( !error->isEmpty() ) {
      QMessageBox::warning( 0, tr("Warning"), *error );
    } else {
      QMessageBox::information( 0, tr("Info"), tr("The table was created") );
      QString str;
      str.sprintf ( "%d", field );
      mFieldBox->insertItem( str );
    }
    delete error;
  } else { 
#ifdef QGISDEBUG
    std::cerr << "Alter table" << std::endl;
#endif

    for ( int i = 0; i < mAttributeTable->numRows(); i++ ) {
      if ( !(mAttributeTable->item(i,0)->isEnabled()) ) continue;

      sql = mAttributeTable->item(i,0)->text() + " " + mAttributeTable->item(i,1)->text();

      if ( mAttributeTable->item(i,1)->text().compare("varchar") == 0 ) {
        sql.append ( " (" + mAttributeTable->item(i,2)->text() + ")" );
      }

      QString *error = mProvider->addColumn ( field, sql );  

      if ( !error->isEmpty() ) {
        QMessageBox::warning( 0, tr("Warning"), *error );
      }
      delete error;
    }
  }

  setAttributeTable ( field );
}

void QgsGrassEdit::changeSymbology(Q3ListViewItem * item, const QPoint & pnt, int col)
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::changeSymbology() col = " << col << std::endl;
#endif

  QSettings settings;

  if ( !item ) return;

  int index = item->text(3).toInt();

  if ( col == 0 ) { 
    if ( index == SYMB_BACKGROUND || index == SYMB_HIGHLIGHT || index == SYMB_DYNAMIC ) return; 

    Q3CheckListItem *clvi = (Q3CheckListItem *) item;
    mSymbDisplay[index] = clvi->isOn();

    //int ww = settings.readNumEntry("/GRASS/windows/edit/w", 420);
    QString sn;
    // TODO use a name instead of index
    sn.sprintf( "/GRASS/edit/symb/display/%d", index );
    settings.writeEntry ( sn, mSymbDisplay[index] );
  } else if ( col == 1 ) {
    QColor color = QColorDialog::getColor ( mSymb[index].color(), this );
    mSymb[index].setColor( color );

    QPixmap pm ( 40, 15 );
    pm.fill( mSymb[index].color() );
    item->setPixmap ( 1, pm );

    QString sn;
    // TODO use a name instead of index
    sn.sprintf( "/GRASS/edit/symb/color/%d", index );
    settings.writeEntry ( sn, mSymb[index].color().name() );
  }
}

void QgsGrassEdit::lineWidthChanged()
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::lineWidthChanged()" << std::endl;
#endif
  QSettings settings;
  mLineWidth = mLineWidthSpinBox->value();

  for ( int i = 0; i < SYMB_COUNT; i++ ) {
    mSymb[i].setWidth( mLineWidth );
  }

  QString spath = "/GRASS/edit/symb/";
  settings.writeEntry ( spath + "lineWidth", mLineWidth );
}

void QgsGrassEdit::markerSizeChanged()
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::markerSizeChanged()" << std::endl;
#endif
  QSettings settings;
  mSize = mMarkerSizeSpinBox->value();
  QString spath = "/GRASS/edit/symb/";
  settings.writeEntry ( spath + "markerSize", mSize );
}

void QgsGrassEdit::restorePosition()
{
  QSettings settings;
  restoreGeometry(settings.value("/GRASS/windows/edit/geometry").toByteArray());
}

void QgsGrassEdit::saveWindowLocation()
{
  QSettings settings;
  settings.setValue("/GRASS/windows/edit/geometry", saveGeometry());
} 

void QgsGrassEdit::updateSymb ( void )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::updateSymb" << std::endl;
#endif

  // Set lines symbology from map
  unsigned int nlines = mProvider->numLines(); 
  if ( nlines+1 >= mLineSymb.size() )
    mLineSymb.resize(nlines+1000); 

  nlines = mProvider->numUpdatedLines();
  for ( unsigned int i = 0; i < nlines; i++ ) {
    int line = mProvider->updatedLine(i);
    std::cerr << "updated line = " << line << std::endl;
    if ( !(mProvider->lineAlive(line)) ) continue;
    mLineSymb[line] = lineSymbFromMap ( line );
  }

  // Set nodes symbology from map
  unsigned int nnodes = mProvider->numNodes(); 
  if ( nnodes+1 >= mNodeSymb.size() )
    mNodeSymb.resize(nnodes+1000); 

  nnodes = mProvider->numUpdatedNodes(); 
  for ( unsigned int i = 0; i < nnodes; i++ ) {
    int node = mProvider->updatedNode(i);
    if ( !(mProvider->nodeAlive(node)) ) continue;
    mNodeSymb[node] = nodeSymbFromMap ( node );
    std::cerr << "node = " << node << " mNodeSymb = " << mNodeSymb[node] << std::endl;
  }
}

int QgsGrassEdit::nodeSymbFromMap ( int node )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::nodeSymbFromMap() node = " <<  node << std::endl;
#endif

  int nlines = mProvider->nodeNLines ( node );

  int count = 0;

  for ( int i = 0; i < nlines; i++ ) {
    int line = abs (  mProvider->nodeLine(node,i) );
    int type = mProvider->readLine ( NULL, NULL, line );

    if ( type & GV_LINES )
      count++;
  }

  if ( count == 0 ) 
    return SYMB_NODE_0;
  else if ( count == 1 )
    return SYMB_NODE_1;

  return SYMB_NODE_2;
}

int QgsGrassEdit::lineSymbFromMap ( int line )
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::lineSymbFromMap() line = " << line << std::endl;
#endif

  int type = mProvider->readLine ( NULL, NULL, line );

  if ( type < 0 ) return 0;

  switch ( type ) {
    case GV_POINT:
      return SYMB_POINT;
      break;

    case GV_LINE:
      return SYMB_LINE;
      break;

    case GV_BOUNDARY:
      int left, right, nareas;

      if ( !(mProvider->lineAreas(line, &left, &right)) ) return 0;

      /* Count areas/isles on both sides */
      nareas = 0;
      if ( left != 0 ) nareas++;
      if ( right != 0 ) nareas++;
      if ( nareas == 0 ) return SYMB_BOUNDARY_0;
      else if ( nareas == 1 ) return SYMB_BOUNDARY_1;
      else return SYMB_BOUNDARY_2;
      break;

    case GV_CENTROID:
      int area = mProvider->centroidArea ( line );
      if ( area == 0 ) return SYMB_CENTROID_OUT;
      else if ( area > 0 ) return SYMB_CENTROID_IN;  
      else return SYMB_CENTROID_DUPL; /* area < 0 */ 
      break;
  }

  return 0; // Should not happen
}

QgsGrassEdit::~QgsGrassEdit()
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassEdit::~QgsGrassEdit()" << std::endl;
#endif

  // we can only call some methods if init was complete,
  // note that we cannot use mValid because it is disabled before
  // destructor is called
  if (mInited) 
  {
    // delete tool if exists
    delete mMapTool;

    eraseDynamic();
    mRubberBandLine->hide();
    mRubberBandIcon->hide();
    mRubberBandLine->reset();
    delete mRubberBandLine;
    delete mRubberBandIcon;

    delete mCanvasEdit;

    mCanvas->refresh();

    saveWindowLocation();
  }
  mRunning = false;
}

bool QgsGrassEdit::isRunning(void)
{
  return mRunning;
}

bool QgsGrassEdit::isValid(void)
{
  return mValid;
}