qgsgrassmapcalc.cpp

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

  }

  // Selection
  if ( mSelected ) 
  {
    painter.setPen( QColor(0,255,255) );
    painter.setBrush( QColor(0,255,255) );

    int s = mSelectionBoxSize;

    painter.drawRect ( mRect.x(), mRect.y(), s, s );
    painter.drawRect ( mRect.x()+mRect.width()-s, mRect.y(), s, s );
    painter.drawRect ( mRect.x()+mRect.width()-s, 
      mRect.y()+mRect.height()-s, s, s );
    painter.drawRect ( mRect.x(), mRect.y()+mRect.height()-s, s, s );
  }
}

void QgsGrassMapcalcObject::setCenter( int x, int y )
{
  //    std::cerr << "QgsGrassMapcalcObject::setCenter() x = " << x << " y = " << y << std::endl;
  mCenter.setX(x);
  mCenter.setY(y);
  resetSize();
  //QCanvasRectangle::update();
}

void QgsGrassMapcalcObject::resetSize()
{
  mSocketHalf = (int) ( mFont.pointSize()/3 + 1 );
  mSpace = (int) ( 1.0*mFont.pointSize() );
  mRound = (int) ( 1.0*mTextHeight );
  mMargin = 2*mSocketHalf+1;

  QFontMetrics metrics ( mFont );
  mTextHeight = metrics.height();

  mInputTextWidth = 0;
  if ( mType == Function )
  {
    for ( int i = 0; i < mFunction.inputLabels().size(); i++ ) 
    {
      /*
      QStringList::Iterator it = mFunction.inputLabels().at(i); 
      QString l = *it;
      */
      QString l = mFunction.inputLabels().at(i); 
      int len = metrics.width ( l );
      if ( len > mInputTextWidth ) mInputTextWidth = len;
    }
  }

  int labelTextWidth = metrics.width ( mLabel );
  if ( mType == Function && !mFunction.drawlabel() )
  {
    labelTextWidth = 0;
  }

  // Drawn rectangle
  int width = mSpace + mInputTextWidth + labelTextWidth;
  if ( mInputTextWidth > 0 && !mLabel.isEmpty() )
  {
    width += mSpace; 
  }	
  if ( labelTextWidth > 0 )
  {
    width += mSpace; 
  }
  int height;
  if ( mInputCount > 0 )
  {
    height = mInputCount*(mTextHeight+mSpace) + mSpace;
  }
  else // Label only
  {
    height = 2*mSpace + mTextHeight;
  }

  mRect.setX ( (int)(mCenter.x()-width/2) );
  mRect.setY ( (int)(mCenter.y()-height/2) );
  mRect.setSize ( QSize(width, height) );

  Q3CanvasRectangle::setX ( mRect.x()-mMargin );
  Q3CanvasRectangle::setY ( mRect.y()-mMargin );
  Q3CanvasRectangle::setSize ( width+2*mMargin, height+2*mMargin );

  // Label rectangle
  int lx = mRect.x()+mSpace;
  if ( mInputTextWidth > 0 )
  {
    lx += mInputTextWidth + mSpace;
  }
  int ly = mRect.y()+mSpace;
  if ( mInputCount > 1 )
  {
    ly += (int)( (mInputCount*mTextHeight + 
      (mInputCount-1)*mSpace)/2 - mTextHeight/2 );
  }
  mLabelRect.setX(lx);
  mLabelRect.setY(ly);
  mLabelRect.setSize ( QSize(labelTextWidth, mTextHeight) );

  // Input sockets
  mInputPoints.resize( mInputCount );

  for ( int i = 0; i < mInputCount; i++ )
  {
    mInputPoints[i] = QPoint ( mRect.x()-mSocketHalf-1, 
      (int)(mRect.y() + (i+1)*(mSpace+mTextHeight) - mTextHeight/2) );
  }

  // Output socket
  mOutputPoint.setX ( mRect.right()+mSocketHalf+1 );
  mOutputPoint.setY ( (int) ( mRect.y()+mRect.height()/2 ) );

  // Update all connected connectors
  for ( int i = 0; i < mInputCount; i++ )
  { 
    if ( mInputConnectors[i] )
    {
      mInputConnectors[i]->repaint();
    }
  }
  if ( mOutputConnector )
  {
    mOutputConnector->repaint();
  }

  Q3CanvasRectangle::update();
}

void QgsGrassMapcalcObject::setValue ( QString value, QString lab )
{
  mValue = value;
  if ( lab.isEmpty() ) {
    mLabel = mValue;
  }
  else
  {
    mLabel = lab;
  }

  resetSize();
}

void QgsGrassMapcalcObject::setFunction ( QgsGrassMapcalcFunction f )
{
  mValue = f.name();
  //mLabel = f.label();
  mLabel = f.name();
  mFunction = f;

  mInputCount = f.inputCount();
  mOutputCount = 1;

  mInputConnectors.resize( mInputCount );
  mInputConnectorsEnd.resize( mInputCount );

  resetSize();
}

void QgsGrassMapcalcObject::setSelected(bool s)
{
  mSelected = s;
  Q3CanvasRectangle::update();
}

bool QgsGrassMapcalcObject::tryConnect( QgsGrassMapcalcConnector *connector,
                                        int end  )
{
  std::cerr << "QgsGrassMapcalcObject::connect" << std::endl;

  QPoint p = connector->point ( end );

  // Input
  if ( !connector->connected(In) ) 
  {
    for ( int i = 0; i < mInputCount; i++ )
    {
      if ( mInputConnectors[i] ) continue; // used

      double d = sqrt ( pow( (double)(mInputPoints[i].x() - p.x()), 2.0 )
        + pow( (double)(mInputPoints[i].y() - p.y()), 2.0 ) );

      if ( d <= mSocketHalf )
      {
        std::cerr << "Object: connector connected to input " << i << std::endl;
        connector->setSocket  ( end, this, In, i ); 
        mInputConnectors[i] = connector;
        return true;
      }
    }
  }

  // Output
  if ( !connector->connected(Out) && !mOutputConnector )
  {
    double d = sqrt ( pow( (double)(mOutputPoint.x() - p.x()), 2.0 )
      + pow( (double)(mOutputPoint.y() - p.y()), 2.0 ) );

    if ( d <= mSocketHalf )
    {
      std::cerr << "Object: connector connected to output " << std::endl;
      connector->setSocket  ( end, this, Out ); 
      mOutputConnector = connector;
      return true;
    }
  }

  return false;
}

void QgsGrassMapcalcObject::setConnector ( int direction, int socket,
                                           QgsGrassMapcalcConnector *connector, int end )
{
  std::cerr << "QgsGrassMapcalcObject::setConnector" << std::endl;

  if ( direction == In )
  {
    mInputConnectors[socket] = connector;
    mInputConnectorsEnd[socket] = end;
  }
  else 
  {
    mOutputConnector = connector;
    mOutputConnectorEnd = end;
  }

  Q3CanvasRectangle::update();
}

QPoint QgsGrassMapcalcObject::socketPoint ( int direction , int socket  )
{
  //    std::cerr << "QgsGrassMapcalcObject::socketPoint" << std::endl;

  if ( direction == In )
  {
    return mInputPoints[socket];
  }

  return mOutputPoint;
}

QString QgsGrassMapcalcObject::expression()
{
  std::cerr << "QgsGrassMapcalcObject::expression()" << std::endl;
  std::cerr << "mType = " << mType << std::endl;

  if ( mType == Map || mType == Constant )
  {
    return mValue;
  }

  if ( mType == Output )
  {
    if ( mInputConnectors[0] )
      //return mInputConnectors[0]->expression();
      return "(" + mInputConnectors[0]->expression() + ")";
    else
      return "null()";	    
  }

  // Functions and operators
  QString exp;

  if ( mFunction.type() == QgsGrassMapcalcFunction::Function )
    exp.append ( mFunction.name() );

  exp.append ( "(" );

  for ( int i = 0; i < mInputCount; i++ )
  { 
    if ( i > 0 )
    {
      if ( mFunction.type() == QgsGrassMapcalcFunction::Function )
        exp.append ( "," );
      else
        exp.append ( mFunction.name() );
    }

    if ( mInputConnectors[i] )
      exp.append ( mInputConnectors[i]->expression() );
    else
      exp.append ( "null()" );

  }

  exp.append ( ")" );

  std::cerr << "exp = " << exp.local8Bit().data() << std::endl;
  return exp;
}

/************************* CONNECTOR **********************************/
QgsGrassMapcalcConnector::QgsGrassMapcalcConnector( Q3Canvas *canvas )
       :Q3CanvasLine(canvas), QgsGrassMapcalcItem()
{
#ifdef QGISDEBUG
  std::cerr << "QgsGrassMapcalcConnector::QgsGrassMapcalcConnector()" << std::endl;
#endif

  Q3CanvasLine::setZ(10);
  setActive(true);

  mPoints.resize(2);
  mPoints[0] = QPoint ( -1000, -1000 );
  mPoints[1] = QPoint ( -1000, -1000 );

  mSocketObjects.resize(2);
  mSocketObjects[0] = 0;
  mSocketObjects[1] = 0;
  mSocketDir.resize(2);
  mSocket.resize(2);
}

QgsGrassMapcalcConnector::~QgsGrassMapcalcConnector()
{
  // Disconnect
  setSocket(0); 
  setSocket(1); 
}

void QgsGrassMapcalcConnector::draw( QPainter & painter )
{
  for ( int i = 0; i < 2; i++ ) 
  {
    if ( mSocketObjects[i] ) {
      mPoints[i] = mSocketObjects[i]->socketPoint ( mSocketDir[i], 
        mSocket[i] );
    }
  }

  if ( !mSocketObjects[0] || !mSocketObjects[1] )
  {
    painter.setPen ( QPen(QColor(255,0,0)) );
  }
  else
  {
    painter.setPen ( QPen(QColor(0,0,0)) );
  }

  painter.drawLine ( mPoints[0], mPoints[1] );

  if ( mSelected )
  {
    painter.setPen ( QPen(QColor(0,255,255), 0, Qt::DotLine ) );
  } 
  painter.drawLine ( mPoints[0], mPoints[1] );
}

void QgsGrassMapcalcConnector::repaint()
{
  setPoint ( 0, point (0) );
  //QCanvasLine::setX(QCanvasLine::x());
  Q3CanvasLine::update();
}

void QgsGrassMapcalcConnector::setPoint ( int index, QPoint point  )
{
  //    std::cerr << "QgsGrassMapcalcConnector::setPoint index = " << index << std::endl;

  mPoints[index] = point;
  Q3CanvasLine::setPoints ( mPoints[0].x(), mPoints[0].y(), 
    mPoints[1].x(), mPoints[1].y() );
  Q3CanvasLine::update();
}

QPoint QgsGrassMapcalcConnector::point ( int index )
{
  return ( mPoints[index] );
}

void QgsGrassMapcalcConnector::setSelected(bool s)
{
  mSelected = s;
  Q3CanvasLine::update();
}

void QgsGrassMapcalcConnector::selectEnd( QPoint point )
{
  std::cerr << "QgsGrassMapcalcConnector::selectEnd" << std::endl;
  mSelectedEnd = -1;

  double d0 = sqrt ( pow((double)(point.x()-mPoints[0].x()),2.0) 
    + pow((double)(point.y()-mPoints[0].y()),2.0) );

  double d1 = sqrt ( pow((double)(point.x()-mPoints[1].x()),2.0) 
    + pow((double)(point.y()-mPoints[1].y()),2.0) );


  if ( d0 < 15 || d1 < 15 )
  {
    if ( d0 < d1 )
    {
      mSelectedEnd = 0;
    }
    else
    {
      mSelectedEnd = 1;
    }
  }
  std::cerr << "mSelectedEnd = " << mSelectedEnd << std::endl;
}

int QgsGrassMapcalcConnector::selectedEnd()
{
  return mSelectedEnd;
}

bool QgsGrassMapcalcConnector::tryConnectEnd( int end )
{
  std::cerr << "QgsGrassMapcalcConnector::tryConnect" << std::endl;

  Q3CanvasItemList l = canvas()->collisions( mPoints[end] );
  QgsGrassMapcalcObject *object = 0;
  for ( Q3CanvasItemList::Iterator it=l.fromLast(); it!=l.end(); --it) 
  {
    if (! (*it)->isActive() ) continue;

    if ( typeid (**it) == typeid (QgsGrassMapcalcObject) )
    {
      object = dynamic_cast <QgsGrassMapcalcObject *> (*it);
      break;
    }
  }

  if ( !object ) return false;

  // try to connect
  if ( !object->tryConnect ( this, end ) ) return false;

  return true;
}

void QgsGrassMapcalcConnector::setSocket( int end, 
                                          QgsGrassMapcalcObject *object, int direction, int socket )
{
  std::cerr << "QgsGrassMapcalcConnector::setSocket" << std::endl;

  // Remove old connection from object
  if ( mSocketObjects[end] )
  {
    mSocketObjects[end]->setConnector ( mSocketDir[end], 
      mSocket[end] );

    mSocketObjects[end] = 0;
  }

  // Create new connection 
  mSocketObjects[end] = object;
  mSocketDir[end] = direction;
  mSocket[end] = socket;

  if ( !object ) return; // disconnect only

  mSocketObjects[end]->setConnector ( mSocketDir[end], 
    mSocket[end], this, end );
}

bool QgsGrassMapcalcConnector::connected ( int direction )
{
  for ( int i = 0; i < 2; i++ )
  {
    if ( mSocketObjects[i] )
    {
      if ( mSocketDir[i] == direction )
      {
        return true;
      }
    }
  }
  return false;
}

QString QgsGrassMapcalcConnector::expression()
{
  std::cerr << "QgsGrassMapcalcConnector::expression()" << std::endl;
  for ( int i = 0; i < 2; i++ )
  {
    if ( !mSocketObjects[i] ) continue;
    if ( mSocketDir[i] != QgsGrassMapcalcObject::Out ) continue;
    return mSocketObjects[i]->expression();
  }

  return "null()";
}

QgsGrassMapcalcObject *QgsGrassMapcalcConnector::object( int end )
{
  return mSocketObjects[end];
}

/************************* FUNCTION *****************************/
QgsGrassMapcalcFunction::QgsGrassMapcalcFunction ( int type, QString name, 
                                                   int count, QString description, QString label, QString labels,
                                                   bool drawLabel ) :
  mName(name), mType(type), mInputCount(count), 
  mLabel(label), mDescription(description),
  mDrawLabel(drawLabel)
{
  if ( mLabel.isEmpty() ) mLabel = mName;

  if ( !labels.isEmpty() )
  {
    mInputLabels = QStringList::split ( ",", labels );
  }
}

/******************** CANVAS VIEW ******************************/

QgsGrassMapcalcView::QgsGrassMapcalcView( QgsGrassMapcalc *mapcalc, 
      QWidget* parent, const char* name, Qt::WFlags f) :
      Q3CanvasView(parent,name,f|Qt::WNoAutoErase|Qt::WResizeNoErase|Qt::WStaticContents)
{
  mMapcalc = mapcalc;

  // TODO: nothing does work -> necessary to call setFocus ()
  setEnabled ( true );
  setFocusPolicy ( Qt::StrongFocus );
  setFocusProxy ( 0 );
}

void QgsGrassMapcalcView::contentsMousePressEvent(QMouseEvent* e)
{
  // TODO: find how to get focus without setFocus
  setFocus ();
  mMapcalc->contentsMousePressEvent(e);
}

void QgsGrassMapcalcView::contentsMouseReleaseEvent(QMouseEvent* e)
{
  mMapcalc->contentsMouseReleaseEvent(e);
}

void QgsGrassMapcalcView::contentsMouseMoveEvent(QMouseEvent* e)
{
  mMapcalc->contentsMouseMoveEvent(e);
}

void QgsGrassMapcalcView::keyPressEvent ( QKeyEvent * e )
{
  mMapcalc->keyPressEvent ( e );
}