GLIMSView Source Code Documentation

vectoreditor.cpp

Go to the documentation of this file.

#include "vectoreditor.h"
#include "TraceLog.h"

VectorEditor::VectorEditor( VectorLayerSet *lyrset,
                            ViewSet *viewset ) :
mLayerSet( lyrset ),
mViewSet( viewset ) {
  mData = NULL;
  mSelSet = NULL;
  init();

  connect( lyrset,
           SIGNAL( activeLayerChanged( int ) ),
           this,
           SLOT( activeLayerChanged( int ) ) );
}

VectorEditor::~VectorEditor( ) {;}

void VectorEditor::addView( View *view ) {
  connect( view,
           SIGNAL( viewMouseMove( QMouseEvent *, View::MouseState & ) ),
           this,
           SLOT( viewMouseMove( QMouseEvent *, View::MouseState & ) ) );

  connect( view,
           SIGNAL( viewMousePress( QMouseEvent *, View::MouseState & ) ),
           this,
           SLOT( viewMousePress( QMouseEvent *, View::MouseState & ) ) );

  connect( view,
           SIGNAL( viewMouseRelease( QMouseEvent *, View::MouseState & ) ),
           this,
           SLOT( viewMouseRelease( QMouseEvent *, View::MouseState & ) ) );

  connect( view,
           SIGNAL( viewKeyPress( QKeyEvent * ) ),
           this,
           SLOT( viewKeyPress( QKeyEvent * ) ) );

  connect( view,
           SIGNAL( viewKeyRelease( QKeyEvent * ) ),
           this,
           SLOT( viewKeyRelease( QKeyEvent * ) ) );
}

void VectorEditor::removeView( View *view ) {
  disconnect( view,
              SIGNAL( viewMouseMove( QMouseEvent *, View::MouseState & ) ),
              this,
              SLOT( viewMouseMove( QMouseEvent *, View::MouseState & ) ) );

  disconnect( view,
              SIGNAL( viewMousePress( QMouseEvent *, View::MouseState & ) ),
              this,
              SLOT( viewMousePress( QMouseEvent *, View::MouseState & ) ) );

  disconnect( view,
              SIGNAL( viewMouseRelease( QMouseEvent *, View::MouseState & ) ),
              this,
              SLOT( viewMouseRelease( QMouseEvent *, View::MouseState & ) ) );

  disconnect( view,
              SIGNAL( viewKeyPress( QKeyEvent * ) ),
              this,
              SLOT( viewKeyPress( QKeyEvent * ) ) );

  disconnect( view,
              SIGNAL( viewKeyRelease( QKeyEvent * ) ),
              this,
              SLOT( viewKeyRelease( QKeyEvent * ) ) );
}

void VectorEditor::init( ) {
  mInObject   = false;
  mCtrlDown   = false;
  mShiftDown  = false;
  mMovingNode = false;
  mOverNode.clear();
}

std::vector<SelectionSet::SelObj> VectorEditor::overSelNode( double x, double y ) {
  std::vector<SelectionSet::SelObj> selobjset;
  if ( mSelSet == NULL ) return selobjset;
  SelectionSet &refSelSet = *mSelSet;
  if ( !mData )
    return selobjset;

  std::vector<Shape*> &xyset = mData->getXYSet();

  if ( mData->getType() == VectorData::POINT ) {
    for ( int iselobj=0; iselobj < refSelSet.size(); iselobj++ ) {
      Shape &s = *xyset[refSelSet[iselobj].obj];
      Node &n = dynamic_cast<Node&>( s );
      if ( fabs( n.x - x ) < 3 ) {
        if ( fabs( n.y - y ) < 3 ) {
          SelectionSet::SelObj selobj;
          selobj.obj = refSelSet[iselobj].obj;
          selobjset.push_back( selobj );
        }
      }
    }
    return selobjset;
  }

  for ( int iselobj=0; iselobj < refSelSet.size(); iselobj++ ) {
    Shape &s = *xyset[refSelSet[iselobj].obj];
    Line &l = dynamic_cast<Line&>( s );
    for ( int inode=0; inode < (int)l.size(); inode++ ) {
      if ( fabs( l[inode].x - x ) < 3 ) {
        if ( fabs( l[inode].y - y ) < 3 ) {
          SelectionSet::SelObj selobj;
          selobj.obj = refSelSet[iselobj].obj;
          selobj.nodes.push_back( inode );
          selobjset.push_back( selobj );
        }
      }
    }
  }

  return selobjset;
}

void VectorEditor::viewMousePress( QMouseEvent *me,
                                   View::MouseState &ms ) {
  if ( !mData )
    return;

  if ( mSelSet == NULL ) return;
  SelectionSet &refSelSet = *mSelSet;

  switch ( View::mTool ) {
    case View::LINE:  // viewMousePress
      if ( me->button() == Qt::LeftButton ) {
        // CONTINUING A LINE
        if ( refSelSet.size() == 1 && refSelSet[0].nodes.size() == 1 ) {
          if ( refSelSet.size() != 1 ) {
            char *msg = "There must be only one node in one line selected to add nodes";
            QMessageBox::information( NULL,
                                      "Editor Error",
                                      msg );
            break;
          }
          mData->push();

          Node node;
          node.x = ms.mCurPos.x;
          node.y = ms.mCurPos.y;
          node.z = 0;

          if ( !mCtrlDown ) {
            mData->addLineNode( node, refSelSet[0].obj, refSelSet[0].nodes[0] );
            // INC THE NODE INDEX SO NEW NODE IS ACTIVE
            refSelSet[0].nodes[0]++;
          } else {
            // SELECTION NODE INDEX STAYS THE SAME HERE
            mData->insertLineNode( node, refSelSet[0].obj, refSelSet[0].nodes[0] );
          }
        }
        // STARTING A NEW LINE
        else if ( refSelSet.size() == 0 || refSelSet.size() > 1) {
          if (refSelSet.size() > 1) {
            refSelSet.clear() ;
          }
          mData->push();
          mInObject = true;
          Node node;
          node.x = ms.mCurPos.x;
          node.y = ms.mCurPos.y;
          mData->addLine( node );
          //refSelSet.clear();
          clearAllLayerSelections () ;
          SelectionSet::SelObj selobj;
          selobj.obj = mData->size() - 1;
          selobj.nodes.push_back( 0 );
          refSelSet.add( selobj );
        }

        mViewSet->repaintViews();
      }
      // FINISH A LINE
      else if ( me->button() == Qt::RightButton ) {

        mData->pushSelection();
        Shape &s = *mData->getXYSet()[refSelSet[0].obj];
        Line &l = dynamic_cast<Line&>( s );
        if ( (int)refSelSet.size() == 1 &&
             (int)refSelSet[0].nodes.size() == 1 &&
             refSelSet[0].nodes[0] == (int)l.size()-1 &&
             mCtrlDown ) {
          Shape &s = *mData->getXYSet()[refSelSet[0].obj];
          Line &l = dynamic_cast<Line&>( s );
          mData->addLineNode( l[0], refSelSet[0].obj );
        }
        mInObject = false;
        //refSelSet.clear();
        clearAllLayerSelections () ;
        mViewSet->repaintViews();
      }
      break;

    case View::GLACIER_ID:
      {
        mData->push();
        Node node;
        node.x = ms.mCurPos.x;
        node.y = ms.mCurPos.y;
        node.z = 0;
        mData->addNode( node );
        mViewSet->repaintViews();

        emit selectionChanged() ;
      }
      break;

    case View::POINTER:
      break;

    case View::SELECTION: // viewMousePress
      if ( mOverNode.size() ) {
        mMovingNode = true;

        //refSelSet.clear();
        clearAllLayerSelections () ;
        refSelSet.add( mOverNode[0] );
      }
      else {
        // push history of selection before clearing selection
        // and setting selection to the current node
        mData->push();
        mData->pushSelection();

        SelectionSet::SelBox &box = refSelSet.selBox();
        box.x = ms.mCurPos.x;
        box.y = ms.mCurPos.y;
        box.w = 0;
        box.h = 0;
        refSelSet.setSelecting( true );
      }
      mViewSet->repaintViews();

      emit selectionChanged() ;

      break;

    default:
      break;
  }
}

void VectorEditor::viewMouseMove( QMouseEvent *,
                                  View::MouseState &ms ) {

  if ( mSelSet == NULL )return;
  SelectionSet &refSelSet = *mSelSet;

  if ( !mData )
    return;

  switch ( View::mTool ) {
    case View::LINE:
      break;

    case View::GLACIER_ID:
      break;

    case View::POINTER:
      break;

    case View::SELECTION:
      if ( mMovingNode ) {
        if ( mCtrlDown ) {
          for ( int iobj=0; iobj < (int)mOverNode.size(); iobj++ ) {
            int obj = mOverNode[iobj].obj;
            int n = -1;
            if ( mData->getType() != VectorData::POINT )
              n = mOverNode[iobj].nodes[0];

            Node node;
            node.x = ms.mCurPos.x;
            node.y = ms.mCurPos.y;
            mData->moveLineNode( obj, n, node );
          }
        } else {
          Node node;
          node.x = ms.mCurPos.x;
          node.y = ms.mCurPos.y;
          if ( mData->getType() != VectorData::POINT )
            mData->moveLineNode( mOverNode[0].obj, mOverNode[0].nodes[0], node );
          else
            mData->moveNode( node, mOverNode[0].obj );
        }

        mViewSet->repaintViews();

        emit selectionChanged() ;
      } else {
        mOverNode = overSelNode( ms.mCurPos.x, ms.mCurPos.y );
        if ( mOverNode.size() ) {
          QApplication::setOverrideCursor( Qt::crossCursor, true );
        } else {
          QApplication::setOverrideCursor( Qt::arrowCursor, true );
        }
      }

      if ( !mMovingNode && refSelSet.isSelecting() ) {
        // THIS CHANGES THE SELECTION BOX FOR THE VIEWS, BUT I THINK
        // THIS SHOULD BE DONE IN THE VIEW CLASS ITSELF OR MAKE THE
        // SELECTBOX DIMENSIONS STATIC AND CHANGE THEM DIRECTLY FROM
        // HERE, BUT THEN WHAT'S THE POINT.
        SelectionSet::SelBox &box = refSelSet.selBox();
        Rect dim;
        dim.x = _int_min( (int)box.x, (int)ms.mCurPos.x );
        dim.y = _int_min( (int)box.y, (int)ms.mCurPos.y );
        dim.w = _int_max( (int)box.x, (int)ms.mCurPos.x ) - dim.x;
        dim.h = _int_max( (int)box.y, (int)ms.mCurPos.y ) - dim.y;

        mViewSet->setSelBox( dim );
        mViewSet->repaintViews();        
        
        emit selectionChanged() ;
      }
      break;

    default:
      break;
  }

}

void VectorEditor::viewMouseRelease( QMouseEvent *,
                                     View::MouseState &ms ) {
  if ( !mData )
    return;

  if ( mSelSet == NULL ) return;
  SelectionSet &refSelSet = *mSelSet;

  switch ( View::mTool ) {
    case View::LINE:
      break;

    case View::GLACIER_ID:
      break;

    case View::POINTER:
      break;

    case View::SELECTION: // viewMouseRelease
      // if user was moving a node, set this action to stopped
      if ( mMovingNode ) {
        mMovingNode = false;
      }
      // otherwise, the user has completed creating a selection box
      else {
        if ( refSelSet.isSelecting() ) {
          SelectionSet::SelBox &boxref = refSelSet.selBox();
          SelectionSet::SelBox box = boxref;

          boxref.x = _int_min( (int)box.x, (int)ms.mCurPos.x );
          boxref.y = _int_min( (int)box.y, (int)ms.mCurPos.y );
          boxref.w = _int_max( (int)box.x, (int)ms.mCurPos.x ) - boxref.x;
          boxref.h = _int_max( (int)box.y, (int)ms.mCurPos.y ) - boxref.y;

          viewSelChanged( refSelSet.selBox() );
          refSelSet.resetBox();

          Rect dim;
          dim.x = dim.y = dim.w = dim.h = 0;
          mViewSet->setSelBox( dim );
          mViewSet->repaintViews();

          emit selectionChanged() ;
        }
      }
      break;

    default:
      break;
  }

}

void VectorEditor::viewKeyPress( QKeyEvent *ke ) {
  if ( !mData )
    return;

  switch ( ke->key() ) {
    // user hit SHIFT key
    case Qt::Key_Shift:
      mShiftDown = true;
      break;

    // user hit CONTROL key
    case Qt::Key_Control:
      mCtrlDown = true;
      break;

    // user hit DELETE key
    case Qt::Key_Delete:
      mData->push();
      delSel();
      break;

    // user hit B to BREAK LINE (disabled)
    case Qt::Key_B:
      if ( mCtrlDown ) {
        // mData->breakLine(  );
        mViewSet->repaintViews();
        emit selectionChanged() ;
      }
      break;

    // user hit Z to UNDO or REDO
    case Qt::Key_Z:
      if ( mCtrlDown && mShiftDown) { // REDO Shift-Z
        mData->redo();
        mViewSet->repaintViews();
        emit selectionChanged() ;
      }
      else if ( mCtrlDown ) { // UNDO Z
        mData->pop();
        mViewSet->repaintViews();
        emit selectionChanged() ;
      }
      break;

    // user hit Y to REDO
    case Qt::Key_Y:
      if ( mCtrlDown ) {
        mData->redo();
        mViewSet->repaintViews();
        emit selectionChanged() ;
      }
      break;

    default:
      break;
  }

}

void VectorEditor::viewKeyRelease( QKeyEvent *ke ) {
  switch ( ke->key() ) {
    case Qt::Key_Shift:
      mShiftDown = false;
      break;

    case Qt::Key_Control:
      mCtrlDown = false;
      break;

    default:
      break;
  }

}

void VectorEditor::viewSelChanged( SelectionSet::SelBox &box ) {
  // if there are no vector data, return
  if ( !mData )
    return;

  // if there is no selection set (data selected), return
  if ( mSelSet == NULL )
    return;

  SelectionSet &refSelSet = *mSelSet; // make copy of the selection set
  int ipnt;
  std::vector<Shape*> &objset = mData->getXYSet(); // get the vector data

  // clear current selection if the shift-key's not depressed
  if ( !mShiftDown ) {
    //refSelSet.clear();
    clearAllLayerSelections () ;
  }

  // if the data are point data...
  if ( mData->getType() == VectorData::POINT ) {
    //...for each point...
    for ( int iobj = 0; iobj < (int)objset.size(); iobj++ ) {
      Shape &s = *objset[iobj];
      Node &n = dynamic_cast<Node&>( s );
      int x = (int)n.x;
      int y = (int)n.y;
      // check to see if point is inside the selection box
      if ( x > box.x && x < (box.x + box.w) &&
           y > box.y && y < (box.y + box.h) ) {
        // ...and add this point to the selected vector data
        // (apparently do the same thing no matter what)
        if ( mShiftDown && !isSelLine( iobj ) ) {
          SelectionSet::SelObj selobj;
          selobj.obj = iobj;
          refSelSet.add( selobj );
        }
        else {
          SelectionSet::SelObj selobj;
          selobj.obj = iobj;
          refSelSet.add( selobj );
        }
      }
    }
  }

  // if the data are not point data, apparently, they're line data
  else {
    // for each line...
    for ( int iline = 0 ; iline < (int)objset.size() ; iline++ ) {
      Shape &s = *objset[iline];
      Line &l = dynamic_cast<Line&>( s );
      // for each node (vertex) in the line...
      for ( ipnt = 0 ; ipnt < (int)l.size() ; ipnt++ ) {
        Node n = l[ipnt];
        int x = (int)n.x;
        int y = (int)n.y;
        // if the node is in the selection box...
        if ( x > box.x && x < (box.x + box.w) &&
             y > box.y && y < (box.y + box.h) ) {
          int il = iline, ip = ipnt;
          // if this node in the line isn't already selected...
          if ( !isSelPoint( il, ip ) ) {
            // if this line isn't already selected, put it in the selection list
            if ( il == -1 ) {
              SelectionSet::SelObj selobj;
              selobj.obj = iline;
              // selobj.nodes.push_back( ipnt );
              refSelSet.add( selobj );
              refSelSet[refSelSet.size()-1].nodes.push_back( ipnt );
            }
            // otherwise...
            else {
              refSelSet[il].nodes.push_back( ipnt );
            }
          }
        }
      }

      // if this line isn't selected already,
      // check to see if it intersects the selection box
      // (i.e. no nodes fell in the selection box, but the line does)
      if ( isSelLine( iline ) == -1 ) {
        // for each line segment in the line...
        for ( ipnt = 1 ; ipnt < (int)l.size() ; ipnt++ ) {
          Node p1, p2;
          Node bp1, bp2, bp3, bp4;

          bp1.x = box.x;          // UL
          bp1.y = box.y;
          bp2.x = box.x;          // LL
          bp2.y = box.y + box.h;
          bp3.x = box.x + box.w;  // LR
          bp3.y = bp2.y;
          bp4.x = bp3.x;          // UR
          bp4.y = box.y;

          p1 = l[ ipnt-1 ];
          p2 = l[ ipnt ];

          // does this line segment intersect the selection box?
          if ( hasIntersect( p1, p2, bp1, bp2 ) ||
               hasIntersect( p1, p2, bp2, bp3 ) ||
               hasIntersect( p1, p2, bp3, bp4 ) ||
               hasIntersect( p1, p2, bp4, bp1 ) ) {
            SelectionSet::SelObj selobj;
            selobj.obj = iline;
            refSelSet.add( selobj );
          }
        }
      }
    }
  }

  mViewSet->repaintViews();
  emit selectionChanged() ;
}

void VectorEditor::breakLine( ) {
  if ( !mData ) return;
  if ( mSelSet == NULL )return;

  SelectionSet &refSelSet = *mSelSet;

  int sel1, nod1;
  std::vector<Shape*> &shpset = mData->getXYSet();

  if ( refSelSet.size() != 1 ) {
    QMessageBox::information( NULL,
                              "Join Line Error",
                              "There must be only one line selected" );
    return;
  }

  if ( refSelSet[0].nodes.size() != 1 ) {
    QMessageBox::information( NULL,
                              "Join Line Error",
                              "There must be one point selected in one line" );
    return;
  }

  sel1 = refSelSet[0].obj;
  if ( sel1 < 0 || sel1 >= (int)shpset.size() )
    return;

  Shape &s1 = *shpset[ sel1 ];
  Line &l1 = dynamic_cast<Line&>( s1 );

  nod1 = refSelSet[0].nodes[0];
  if ( nod1 <= 0 || nod1 >= (int)l1.size()-1 ) {
    QMessageBox::information( NULL,
                              "Join Line Error",
                              "There must be one point selected in one line" );
    return;
  }

  mData->breakLine( sel1, nod1 );
  mViewSet->repaintViews();
  emit selectionChanged() ;
}

void VectorEditor::joinLine( ) {
  if ( !mData ) return;
  if ( mSelSet == NULL )return;
  SelectionSet &refSelSet = *mSelSet;

  int sel1, sel2, nod1, nod2;
  std::vector<Shape*> &shpset = mData->getXYSet();

  if ( refSelSet.size() != 2 ) {
    QMessageBox::information( NULL,
                              "Join Line Error",
                              "There must be two lines selected" );
    return;
  }

  // huh? repetition of above check
  if ( refSelSet.size() != 2 ) {
    QMessageBox::information( NULL,
                              "Join Line Error",
                              "There must be two end points selected in two lines" );
    return;
  }

  sel1 = refSelSet[0].obj;
  sel2 = refSelSet[1].obj;
  if ( sel1 < 0 || sel1 >= (int)shpset.size() ||
       sel2 < 0 || sel2 >= (int)shpset.size() )
    return;

  Shape &s1 = *shpset[ sel1 ];
  Shape &s2 = *shpset[ sel2 ];

  Line &l1 = dynamic_cast<Line&>( s1 );
  Line &l2 = dynamic_cast<Line&>( s2 );

  nod1 = refSelSet[0].nodes[0];
  nod2 = refSelSet[1].nodes[0];
  if ( !(nod1 == 0 || nod1 == (int)l1.size()-1) ||
       !(nod2 == 0 || nod2 == (int)l2.size()-1) ) {
    QMessageBox::information( NULL,
                              "Join Line Error",
                              "There must be two end points selected in two lines" );
    return;
  }

  mData->pushSelection();
  mSelSet->erase(1) ;
  mData->joinLine( sel1, sel2, nod1, nod2 );


  mViewSet->repaintViews();
  emit selectionChanged() ;

}

void VectorEditor::contLine( ) {
  /*
  if( !mData )
      return;

  std::vector<Line> &xyobjset = mLayer->getXYObjSet();

  if( refSelSet.size() != 1 ||
      refSelSet[0].nodes.size() != 1 )
  {
      QMessageBox::information(
          NULL,
          "",
          "There must be one node selected to continue a line" );
  }

  */

}

void VectorEditor::delSel( ) {
  if ( !mData ) return;

  if ( mSelSet == NULL ) return;
  SelectionSet &refSelSet = *mSelSet;

  // delete a point
  if ( mData->getType() == VectorData::POINT ) {

    // for each SelObj to be deleted in the SelectionSet
    for ( int isel = 0 ; isel < (int)refSelSet.size() ; isel++ ) {

      // for each SelObj remaining in the SelectionSet
      for ( int i = 0 ; i < (int)refSelSet.size() ; i++ ) {

        // compare the objs in the SelObjs, and
        // bump the remaining ones down a notch if they're
        // greater than the one to be deleted
        if ( refSelSet[isel].obj < refSelSet[i].obj ) {
          refSelSet[i].obj--;
        }

      } // end for the remining SelObjs
      mData->delNode( refSelSet[isel].obj );

    } // end for the SelObjs to be deleted
    clearAllLayerSelections () ;

  }

  // delete a line
  else {
    int szLine = 0;
    for ( int isel=0; isel < (int)refSelSet.size(); isel++ ) {
      Shape &s = *mData->getXYSet()[ refSelSet[isel].obj ];
      Line &l = dynamic_cast<Line&>( s );
      szLine = l.size();
      if ( mCtrlDown || szLine <= (int)refSelSet[isel].nodes.size() ) {
        for ( int i=0; i < (int)refSelSet.size(); i++ ) {
          if ( refSelSet[isel].obj < refSelSet[i].obj ) {
            refSelSet[i].obj--;
          }
        }
        mData->delLine( refSelSet[isel].obj );
      }
      else {
        sort( refSelSet[isel].nodes.begin(), refSelSet[isel].nodes.end() );
        for ( int inode=refSelSet[isel].nodes.size()-1; inode > -1; inode-- ) {
          mData->delLineNode( refSelSet[isel].obj, refSelSet[isel].nodes[inode] );
        }
      }
    }

    if ( !mCtrlDown && refSelSet.size() == 1 && refSelSet[0].nodes.size() == 1 ) {
      if ( refSelSet[0].nodes[0] >= szLine-1 ) {
        refSelSet[0].nodes[0]--;
      }
      if ( refSelSet[0].nodes[0] < 0 ) {
        clearAllLayerSelections () ;
      }
    }
    else {
      clearAllLayerSelections () ;
    }
  }

  mViewSet->repaintViews();
  emit selectionChanged() ;

}

bool VectorEditor::hasIntersect( Node p1,
                                 Node p2,
                                 Node p3,
                                 Node p4 ) {
  if ( p1.x - p2.x == 0 )
    p1.x -= 0.01;
  if ( p3.x - p4.x == 0 )
    p3.x -= 0.01;

  double m1 = ( p1.y - p2.y ) / ( p1.x - p2.x );
  double m2 = ( p3.y - p4.y ) / ( p3.x - p4.x );

  // PARRALEL
  if ( m1 == m2 )
    return false;

  double b1 = p1.y - m1 * p1.x;
  double b2 = p3.y - m2 * p3.x;

  double ix = ( b1 - b2 ) / ( m2 - m1 );

  if ( p1.x < p2.x ) {
    if ( p1.x > ix || p2.x < ix )
      return false;
  } else {
    if ( p2.x > ix || p1.x < ix )
      return false;
  }

  if ( p3.x < p4.x ) {
    if ( p3.x > ix || p4.x < ix )
      return false;
  } else {
    if ( p4.x > ix || p3.x < ix )
      return false;
  }

  return true;
}

int VectorEditor::isSelLine( int iline ) {
  if ( mSelSet == NULL )return -1;
  SelectionSet &refSelSet = *mSelSet;

  for ( int i = 0 ; i < refSelSet.size() ; i++ ) {
    // look for SelectSet obj matching param iline
    // return index of SelectSet where iline is found
    // or -1 if not found
    if ( refSelSet[i].obj == iline )
      return i;
  }
  return -1;
}

bool VectorEditor::isSelPoint( int &il, int &ip ) {
  if ( mSelSet == NULL )return false;
  SelectionSet &refSelSet = *mSelSet;

  int sl, sp;
  // if the line isn't in the Select Set, return -1
  if ( (sl = isSelLine( il )) == -1 ) {
    il = -1;
    ip = -1;
    return false;
  }

  // set the line to the index it was found at in the SelectionSet
  il = sl;

  // now, look for the matching Node in the Line represented by the SelObj (refSelSet[sl])
  for ( sp = 0 ; sp < (int)refSelSet[sl].nodes.size() ; sp++ ) {
    if ( refSelSet[sl].nodes[sp] == ip )
      break;
  }

  // set the line to the index for that line in the SelectionSet
  // set the point to the index for that point from the Nodes array in the SelObj (refSelSet[sl])
  // good job, return true
  if ( sp < (int)refSelSet[sl].nodes.size() ) {
    il = sl;
    ip = sp;
    return true;
  }

  // point not found, bye-bye, return false
  ip = -1;
  return false;
}

void VectorEditor::activeLayerChanged( int ilyr ) {
  if ( mLayerSet ) {
    VectorLayer *lyr = mLayerSet->getLayer( ilyr );
    if ( lyr ) {
      mData = lyr->getData();
      if ( mData )
        mSelSet = &mData->getSelSet();
    }
  }

}

void VectorEditor::clearAllLayerSelections() {
  if ( mLayerSet ) {
    for (unsigned int i = 0 ; i < mLayerSet->numLayers() ; i++) {
      VectorLayer *lyr = mLayerSet->getLayer( i );
      if ( lyr ) {
        VectorData *vData = lyr->getData();
        if ( vData ) {
          SelectionSet *nSelSet = &vData->getSelSet();
          if (nSelSet && nSelSet->size()) {
            nSelSet->clear() ;
            emit selectionChanged() ;
          }
        }
      }
    }
  }
}

---

Home | Search | Disclaimers & Privacy | Contact Us GLIMSView Maintainer: dsoltesz@usgs.gov