GLIMSView Source Code Documentation

view.cpp

Go to the documentation of this file.

#include "view.h"
#include <qmessagebox.h>

View::Tool View::mTool = NO_TOOL;
HistogramUser View::mGlbHistUser;

View::View( QWidget *parent ) :
QWidget( parent, "", Qt::WRepaintNoErase | Qt::WResizeNoErase ) {
  init();
  resize( 300, 300 );
}

View::View( QWidget *parent, Image *img, VectorLayerSet *vls ) :
QWidget( parent, "", Qt::WRepaintNoErase | Qt::WResizeNoErase ) {
  init();
  mImage = img;
  mLyrSet = vls;
  resize( 300, 300 );
}

View::~View( ) {
  delete mTimer;
}

void View::init( ) {
  this->setMouseTracking( true );

  mImage          = NULL;
  mCurImg         = NULL;
  mCurScreen        = NULL;
  mDspImg         = true;
  mDspVec         = true;
  mFullRedraw       = true;
  mChildLinked      = false;
  mParentLinked     = false;
  mCTableNew        = true;
  mPaning         = false;

  mLinkBox.moving     = false;
  mLinkBox.dim.x      = -1;
  mLinkBox.dim.y      = -1;
  mLinkBox.dim.w      = -1;
  mLinkBox.dim.h      = -1;

  mVirDims.x        = 0;
  mVirDims.y        = 0;
  mVirDims.w        = 0;
  mVirDims.h        = 0;

  mSelBox.x       = 0;
  mSelBox.y       = 0;
  mSelBox.w       = 0;
  mSelBox.h       = 0;

  mMouse.mLeftButDown     = false;
  mMouse.mRightButDown    = false;
  mMouse.mMidButDown      = false;

  mSclType = ImageFormat::SCALE_NN;

  this->setBackgroundColor( QColor( 0,0,0 ) );
  mTimer = new QTimer( this );
  connect( mTimer, SIGNAL( timeout() ), this, SLOT( timerDone() ) );
}

void View::initView( ) {
  mImage = NULL;
  resetView();

  disconnect( this, SIGNAL( viewMouseMove( QMouseEvent *, View::MouseState & ) ) );
  disconnect( this, SIGNAL( viewMousePress( QMouseEvent *, View::MouseState & ) ) );
  disconnect( this, SIGNAL( viewMouseRelease( QMouseEvent *, View::MouseState & ) ) );
  disconnect( this, SIGNAL( viewKeyPress( QKeyEvent * ) ) );
  disconnect( this, SIGNAL( viewKeyRelease( QKeyEvent * ) ) );
  // disconnect( this, SIGNAL( viewPaintEvent( QPainter &, Rect & ) ) );

  repaint( true );
}

void View::resetView( ) {
  if ( mCurImg )
    delete mCurImg;
  mCurImg = NULL;

  mFullRedraw = true;

  mLinkBox.moving     = false;
  mLinkBox.dim.x      = -1;
  mLinkBox.dim.y      = -1;
  mLinkBox.dim.w      = -1;
  mLinkBox.dim.h      = -1;

  mVirDims.x        = 0;
  mVirDims.y        = 0;
  mVirDims.w        = 0;
  mVirDims.h        = 0;
  //repaint( false );
}

void View::setImage( Image *img ) {
  if ( img == NULL )
    return;

  mImage = img;
  calcDims();
}

void View::setLinkChild( View *parentlink ) {
  disconnect( this, SLOT( setLinkLimits( Rect ) ) );
  disconnect( this, SLOT( setVirDims( Rect ) ) );

  connect( parentlink,
           SIGNAL( parentVirDimsChanged( Rect ) ),
           this,
           SLOT( setLinkLimits( Rect ) ) );

  connect( parentlink,
           SIGNAL( parentLinkBoxChanged( Rect ) ),
           this,
           SLOT( setVirDims( Rect ) ) );

  mLinkLimits = parentlink->getVirDims();
  mParentLinked = true;
  mState.mParentName = parentlink->getViewState().mName;
}

void View::setLinkParent( View *childlink ) {
  disconnect( this, SLOT( setLinkBoxDims( Rect ) ) );

  connect( childlink,
           SIGNAL( childVirDimsChanged( Rect ) ),
           this,
           SLOT( setLinkBoxDims( Rect ) ) );

  mLinkBox.dim = childlink->getVirDims();
  mChildLinked = true;
  mState.mChildName = childlink->getViewState().mName;

}

void View::setLinkLimits( Rect d ) {
  mLinkLimits = d;
}

void View::setVirDims( Rect d ) {
  if ( mChildLinked ) {
    mLinkBox.dim.x += (d.x - mVirDims.x);
    mLinkBox.dim.y += (d.y - mVirDims.y);
    emit parentLinkBoxChanged( mLinkBox.dim );
  }
  mVirDims = d;
  mFullRedraw = true;
  repaint( false );
}

void View::setLinkBoxDims( Rect d ) {
  mLinkBox.dim = d;
  repaint( false );
}

void View::setZoomAttr( ZoomAttr attr ) {
  mState.mZoom = attr;

  switch ( mState.mZoom.type ) {
    case ZoomAttr::SCALE:
    case ZoomAttr::FIXED:
      mVirDims.x = 0;
      mVirDims.y = 0;
      mDspDims.x = 0;
      mDspDims.y = 0;
      mDspDims.w = this->width();
      mDspDims.h = this->height();
      calcDims();
      mFullRedraw = true;
      repaint( false );
      break;

    default:
      break;
  }
}

ZoomAttr* View::getZoomAttr( ) const {
  return(ZoomAttr*)&mState.mZoom;
}

void View::paintEvent( QPaintEvent * ) {
  if ( mImage == NULL || mImage->getImageState().mRed == -1 )
    return;

  QPixmap bufpm( width(), height() );
  QPainter p( &bufpm );

  p.fillRect( 0, 0, width(), height(), QBrush( black ) );

  if ( mFullRedraw ) {

    if ( mCurImg ) {
      delete mCurImg;
    }

    calcDims();

    switch ( mState.mZoom.type ) {
      case ZoomAttr::SCALE:
      case ZoomAttr::FIXED:
        {
          Rect imgdim;
          int imgw = mImage->width();
          int imgh = mImage->height();

          imgdim.x = ( mVirDims.x <= 0 ) ? 0 : mVirDims.x;
          imgdim.y = ( mVirDims.y <= 0 ) ? 0 : mVirDims.y;
          if ( imgdim.x + mVirDims.w > imgw )
            imgdim.w = imgw - imgdim.x;
          else
            imgdim.w = mVirDims.w;
          if ( imgdim.y + mVirDims.h > imgh )
            imgdim.h = imgh - imgdim.y;
          else
            imgdim.h = mVirDims.h;

          if ( imgdim.w <= 0 || imgdim.h <= 0 )
            mCurImg = new QImage;
          else {
            QApplication::setOverrideCursor( Qt::waitCursor, true );
            mCurImg = mImage->getRect( (int)imgdim.x,
                                       (int)imgdim.y,
                                       (int)imgdim.w,
                                       (int)imgdim.h,
                                       (int)(imgdim.w * mState.mZoom.factor),
                                       (int)(imgdim.h * mState.mZoom.factor),
                                       mSclType );
            QApplication::restoreOverrideCursor();
          }

          mDspDims.x = ( imgdim.x - mVirDims.x ) * mState.mZoom.factor;
          mDspDims.y = ( imgdim.y - mVirDims.y ) * mState.mZoom.factor;

        } break;

      case ZoomAttr::WHOLE:
        {
          QApplication::setOverrideCursor( Qt::waitCursor, true );
          mCurImg = mImage->getRect( 0,
                                     0,
                                     mImage->width(),
                                     mImage->height(),
                                     (int)mDspDims.w,
                                     (int)mDspDims.h,
                                     mSclType );
          QApplication::restoreOverrideCursor();
        } break;

      default:
        break;
    }

    mCTableNew = true;
    mFullRedraw = false;

    emit childVirDimsChanged( mVirDims );
    emit parentVirDimsChanged( mVirDims );
    mHistDlg->reloadHistSet();
  }

  if ( mCTableNew ) {
    QImage tmpimg = mCurImg->copy();
    mGlbHistUser.scaleVal( tmpimg.bits(), 4 * tmpimg.width() * tmpimg.height() );

    if ( mCurScreen ) {
      delete mCurScreen; 
    }
    mCurScreen = new QPixmap;

    if (!mCurScreen || !(&tmpimg)) cout << QMessageBox::message("View::paintEvent", "mCurScreen or tmpimage is null") ;
    mCurScreen->convertFromImage( tmpimg );
    mCTableNew = false;
  }

  bitBlt( &bufpm,
          (int)mDspDims.x,
          (int)mDspDims.y,
          mCurScreen, 0, 0,
          mCurScreen->width(), mCurScreen->height() );

  Rect tmpVirDims = mVirDims;
  // if( mState.mZoom.type != WHOLE && (mDspDims.x !=0 || mDspDims.y != 0) )
  if ( mPaning && !mLinkBox.moving ) {
    double vmsedifx = (mMouse.mCurPos.x - mMouse.mStartPos.x) /
                      mState.mZoom.factor;
    double vmsedify = (mMouse.mCurPos.y - mMouse.mStartPos.y) /
                      mState.mZoom.factor;

    tmpVirDims.x -= vmsedifx;
    tmpVirDims.y -= vmsedify;
  }

  p.save();

  for ( unsigned int ilyr=0; ilyr < mLyrSet->numLayers(); ilyr++ ) {
    mLyrSet->getLayer( ilyr )->draw( p, tmpVirDims, mState.mZoom.factor );
  }

  p.restore();

  if ( mChildLinked ) {
    Rect tmp = virDimToDsp( mLinkBox.dim );
    p.setBrush( Qt::NoBrush );
    p.setPen( red );
    p.drawRect( (int)tmp.x,
                (int)tmp.y,
                (int)tmp.w,
                (int)tmp.h );
  }

  if ( mSelBox.w != 0 ) {
    Rect tmp = virDimToDsp( mSelBox );
    p.setBrush( Qt::NoBrush );
    p.setPen( QPen( QColor( 75,75,75 ), 1, Qt::SolidLine ) );
    p.drawRect( (int)tmp.x, (int)tmp.y, (int)tmp.w, (int)tmp.h );
    p.setPen( QPen( QColor( 200,200,200 ), 1, Qt::DashLine ) );
    p.drawRect( (int)tmp.x, (int)tmp.y, (int)tmp.w, (int)tmp.h );
  }

  bitBlt( this, 0, 0, &bufpm, 0, 0, width(), height() );

}

void View::fullRedraw( ) {
  mFullRedraw = true;
  repaint( false );
}

void View::calcDims( ) {

  if ( mImage == NULL )
    return;

  int imgw = mImage->width();
  int imgh = mImage->height();
  int winw = this->width();
  int winh = this->height();

  switch ( mState.mZoom.type ) {
    case ZoomAttr::SCALE:
    case ZoomAttr::FIXED:
      if ( mState.mZoom.factor == 0.0 ) break;
      mVirDims.w = winw / mState.mZoom.factor;
      mVirDims.h = winh / mState.mZoom.factor;
      break;

    case ZoomAttr::FREE:
      break;

    case ZoomAttr::WHOLE:
      {
        double scale1, scale2;
        scale1 = (double)winw / (double)imgw;
        scale2 = (double)winh / (double)imgh;

        if ( scale1 < scale2 ) {
          mState.mZoom.factor = scale1;
          mDspDims.w = imgw * scale1;
          mDspDims.h = imgh * scale1;
          if ( (mDspDims.h/2) == 0 ) break;
          mDspDims.y = (winh/2) - (mDspDims.h/2);
          mDspDims.x = 0;

          if ( scale1 == 0 ) break;
          mVirDims.w = winw / scale1;
          mVirDims.h = winh / scale1;
          mVirDims.x = 0;
          mVirDims.y = -( (mVirDims.h/2) - (imgh/2) );
        } else {
          mState.mZoom.factor = scale2;
          mDspDims.w = imgw * scale2;
          mDspDims.h = imgh * scale2;
          mDspDims.y = 0;
          mDspDims.x = (winw/2)-(mDspDims.w/2);

          if ( scale2 == 0 ) break;
          mVirDims.w = winw / scale2;
          mVirDims.h = winh / scale2;
          mVirDims.x = -( (mVirDims.w/2) - (imgw/2) );
          mVirDims.y = 0;
        }
      }
      break;
  }
}

void View::mouseMoveEvent( QMouseEvent *me ) {
  MousePos mvxy, ll;

  mMouse.mCurPos.x = me->x();
  mMouse.mCurPos.y = me->y();

  if ( !mImage )
    return;

  mvxy = mMouse.mCurPos;
  dspToVir( mvxy.x, mvxy.y );
  ll = mvxy;

  mImage->getLL( ll.x, ll.y );

  emit mousePosChanged( ll, mvxy );

  if ( mMouse.mLeftButDown && mLinkBox.moving ) {
    int mxdif = int( mvxy.x - mLinkBox.origpos.x);
    int mydif = int( mvxy.y - mLinkBox.origpos.y );
    mLinkBox.dim.x = mLinkBox.origpos.x - mLinkBox.xoff + mxdif;
    mLinkBox.dim.y = mLinkBox.origpos.y - mLinkBox.yoff + mydif;
    if ( mLinkBox.dim.x < mVirDims.x )
      mLinkBox.dim.x = mVirDims.x;
    if ( mLinkBox.dim.y < mVirDims.y )
      mLinkBox.dim.y = mVirDims.y;
    if ( mLinkBox.dim.x + mLinkBox.dim.w > mVirDims.x + mVirDims.w )
      mLinkBox.dim.x = mVirDims.x + mVirDims.w - mLinkBox.dim.w;
    if ( mLinkBox.dim.y + mLinkBox.dim.h > mVirDims.y + mVirDims.h )
      mLinkBox.dim.y = mVirDims.y + mVirDims.h - mLinkBox.dim.h;

    // mLinkBox.origpos = mLinkBox.dim;
    repaint( false );

  }

  switch ( mTool ) {
    case PAN_HAND:
      switch ( mState.mZoom.type ) {
        case ZoomAttr::SCALE:
        case ZoomAttr::FIXED:
          if ( mMouse.mLeftButDown && !mLinkBox.moving ) {
            mDspDims.x += (mMouse.mCurPos.x - mMouse.mLastPos.x);
            mDspDims.y += (mMouse.mCurPos.y - mMouse.mLastPos.y);

            repaint( false );
          }
          break;

        default:
          break;
      }
      break;

    default:
      break;
  }

  mMouse.mLastPos.x = mMouse.mCurPos.x;
  mMouse.mLastPos.y = mMouse.mCurPos.y;

  if ( mState.mEditable && !mLinkBox.moving ) {
    MouseState ms = mMouse;
    dspToVir( ms.mCurPos.x, ms.mCurPos.y );
    dspToVir( ms.mLastPos.x, ms.mLastPos.y );
    dspToVir( ms.mStartPos.x, ms.mStartPos.y );

    emit viewMouseMove( me, ms );
  }
}

void View::mousePressEvent( QMouseEvent *me ) {
  mMouse.mStartPos.x = mMouse.mCurPos.x;
  mMouse.mStartPos.y = mMouse.mCurPos.y;
  mMouse.mLastPos.x  = mMouse.mCurPos.x;
  mMouse.mLastPos.y  = mMouse.mCurPos.y;

  if ( me->button() == LeftButton )
    mMouse.mLeftButDown = true;
  else if ( me->button() == RightButton )
    mMouse.mRightButDown = true;


  switch ( mTool ) {
    case PAN_HAND:
      {
        MousePos mvxy;
        mvxy = mMouse.mCurPos;
        dspToVir( mvxy.x, mvxy.y );
        if ( mvxy.x > mLinkBox.dim.x &&
             mvxy.x < mLinkBox.dim.x + mLinkBox.dim.w &&
             mvxy.y > mLinkBox.dim.y &&
             mvxy.y < mLinkBox.dim.y + mLinkBox.dim.h ) {
          mLinkBox.moving = true;
          mLinkBox.origpos = mLinkBox.dim;
          mLinkBox.xoff = (int)(mvxy.x - mLinkBox.dim.x);
          mLinkBox.yoff = (int)(mvxy.y - mLinkBox.dim.y);
        } else {
          mPaning = true;
        }
        break;
      }
    case ZOOMOUT_INC:
      switch ( mState.mZoom.type ) {
        case ZoomAttr::FREE:
        case ZoomAttr::SCALE:
          {
            MousePos vmp = mMouse.mCurPos;
            dspToVir( vmp.x, vmp.y );
            if ( mState.mZoom.factor > 2.0 )
              mState.mZoom.factor -= 1.0;
            else if ( mState.mZoom.factor > 1.0 )
              mState.mZoom.factor = 1.0;
            else
              mState.mZoom.factor -= 0.1;

            if ( mState.mZoom.factor <= 0.1 )
              mState.mZoom.factor = 0.2;
            calcDims();
            mFullRedraw = true;
            centerOn( vmp.x, vmp.y );
            loadCaption();
          }
          break;

        default:
          break;
      }
      break;

    case ZOOMIN_INC:
      switch ( mState.mZoom.type ) {
        case ZoomAttr::FREE:
        case ZoomAttr::SCALE:
          {
            MousePos vmp = mMouse.mCurPos;
            dspToVir( vmp.x, vmp.y );
            if ( mState.mZoom.factor < 1.0 )
              mState.mZoom.factor += 0.1;
            else
              mState.mZoom.factor += 1.0;
            if ( mState.mZoom.factor > 20 )
              mState.mZoom.factor = 20;
            calcDims();
            mFullRedraw = true;
            centerOn( vmp.x, vmp.y );
            loadCaption();
          }
          break;

        default:
          break;
      }
      break;

    default:
      break;
  }

  if ( mState.mEditable && !mLinkBox.moving ) {
    MouseState ms = mMouse;
    dspToVir( ms.mCurPos.x, ms.mCurPos.y );
    dspToVir( ms.mLastPos.x, ms.mLastPos.y );
    dspToVir( ms.mStartPos.x, ms.mStartPos.y );
    emit viewMousePress( me, ms );
  }
}

void View::mouseReleaseEvent( QMouseEvent *me ) {

  mMouse.mLeftButDown     = false;
  mMouse.mRightButDown    = false;
  mMouse.mMidButDown      = false;

  switch ( mTool ) {
    case PAN_HAND:
      mPaning = false;
      switch ( mState.mZoom.type ) {
        case ZoomAttr::SCALE:
        case ZoomAttr::FIXED:
          {
            if ( !mLinkBox.moving ) {
              //int mousedifx = int( (mMouse.mCurPos.x - mMouse.mStartPos.x) / mState.mZoom.factor );
              //int mousedify = int( (mMouse.mCurPos.y - mMouse.mStartPos.y) / mState.mZoom.factor );
              double vmsedifx = (mMouse.mCurPos.x - mMouse.mStartPos.x) /
                                mState.mZoom.factor;
              double vmsedify = (mMouse.mCurPos.y - mMouse.mStartPos.y) /
                                mState.mZoom.factor;
              mVirDims.x -= vmsedifx;
              mVirDims.y -= vmsedify;
              if ( mVirDims.x + mVirDims.w > mLinkLimits.x + mLinkLimits.w )
                mVirDims.x = mLinkLimits.x + mLinkLimits.w - mVirDims.w;
              if ( mVirDims.x < mLinkLimits.x )
                mVirDims.x = mLinkLimits.x;
              if ( mVirDims.y + mVirDims.h > mLinkLimits.y + mLinkLimits.h )
                mVirDims.y = mLinkLimits.y + mLinkLimits.h - mVirDims.h;
              if ( mVirDims.y < mLinkLimits.y )
                mVirDims.y = mLinkLimits.y;

              if ( mChildLinked ) {
                mLinkBox.dim.x -= vmsedifx;
                mLinkBox.dim.y -= vmsedify;
                if ( mLinkBox.dim.x < mVirDims.x )
                  mLinkBox.dim.x = mVirDims.x;
                if ( mLinkBox.dim.y < mVirDims.y )
                  mLinkBox.dim.y = mVirDims.y;
                if ( mLinkBox.dim.x + mLinkBox.dim.w > mVirDims.x + mVirDims.w )
                  mLinkBox.dim.x = mVirDims.x + mVirDims.w - mLinkBox.dim.w;
                if ( mLinkBox.dim.y + mLinkBox.dim.h > mVirDims.y + mVirDims.h )
                  mLinkBox.dim.y = mVirDims.y + mVirDims.h - mLinkBox.dim.h;
                emit parentLinkBoxChanged( mLinkBox.dim );
              }
              calcDims();
              mFullRedraw = true;
              repaint( false );
            }
          }
          break;

        default:
          break;
      }

      break;

    default:
      break;
  }

  if ( mLinkBox.moving ) {
    mLinkBox.moving = false;
    emit parentLinkBoxChanged( mLinkBox.dim );
  } else if ( mState.mEditable ) {
    MouseState ms = mMouse;
    dspToVir( ms.mCurPos.x, ms.mCurPos.y );
    dspToVir( ms.mLastPos.x, ms.mLastPos.y );
    dspToVir( ms.mStartPos.x, ms.mStartPos.y );
    emit viewMouseRelease( me, ms );
  }
}

void View::resizeEvent( QResizeEvent * ) {
  // CALC NEW DSP/VIR DIMS
  calcDims();
  if ( mTimer->isActive() )
    mTimer->stop();
  mTimer->start( 300, true );
  loadCaption();
  repaint( false );
}

void View::keyPressEvent( QKeyEvent *ke ) {
  if ( ke->key() == Qt::Key_C && (ke->state() & ControlButton) ) {
    MousePos tmp = mMouse.mCurPos;
    dspToVir( tmp.x, tmp.y );
    centerOn( tmp.x, tmp.y );
  }
  if ( mState.mEditable )
    emit viewKeyPress( ke );
}

void View::keyReleaseEvent( QKeyEvent *ke ) {
  if ( mState.mEditable )
    emit viewKeyRelease( ke );
}

char* View::getHistName( ) const {
  return(char*)mState.mName.c_str();
}

HistogramSet View::getHistSet( ) const {
  HistogramSet histset;

  unsigned char *rdata, *gdata, *bdata, *imgdata;
  int len;

  if ( mCurImg == NULL )
    return histset;

  QImage &img = *mCurImg;//->copy();
  imgdata = img.bits();

  len = img.width() * img.height();

  rdata = new unsigned char[len];
  gdata = NULL;
  bdata = NULL;

  ImageState st = mImage->getImageState();
  if ( !(st.mRed == st.mGreen && st.mGreen == st.mBlue ) ) {
    gdata = new unsigned char[len];
    bdata = new unsigned char[len];

    for ( int i=0; i < len; i++ ) {
      rdata[i] = imgdata[(i*4)+2];
      gdata[i] = imgdata[(i*4)+1];
      bdata[i] = imgdata[(i*4)+0];
    }
  } else {
    for ( int i=0; i < len; i++ )
      rdata[i] = imgdata[(i*4)+2];
    gdata = NULL;
    bdata = NULL;
  }

  histset.setData( rdata, len, gdata, len, bdata, len );
  delete [] rdata;
  delete [] gdata;
  delete [] bdata;

  return histset;
}

void View::timerDone( ) {
  loadCaption();
  mFullRedraw = true;
  repaint( false );
}

const Rect& View::getVirDims( ) const {
  return mVirDims;
}

void View::dspToVir( double &x, double &y ) {
  double scale = mState.mZoom.factor;

  x = x / scale + mVirDims.x;
  y = y / scale + mVirDims.y;
}

void View::virToDsp( double &x, double &y ) {
  double scale = mState.mZoom.factor;

  x = ( x - mVirDims.x ) * scale;
  y = ( y - mVirDims.y ) * scale;
}

void View::dspToVir( int &x, int &y ) {
  double dx, dy;
  dx = x;
  dy = y;
  dspToVir( dx, dy );
  x = (int)dx;
  y = (int)dy;
}

void View::virToDsp( int &x, int &y ) {
  double dx, dy;
  dx = x;
  dy = y;
  virToDsp( dx, dy );
  x = (int)dx;
  y = (int)dy;
}

Rect View::virDimToDsp( const Rect &d ) {
  double x1, y1, x2, y2;
  Rect dim = d;

  x1 = dim.x;
  y1 = dim.y;
  x2 = (dim.x + dim.w);
  y2 = (dim.y + dim.h);

  virToDsp( x1, y1 );
  virToDsp( x2, y2 );

  dim.x = x1;
  dim.y = y1;
  dim.w = x2 - dim.x;
  dim.h = y2 - dim.y;

  return dim;
}

void View::selBoxChanged( Rect &dim ) {
  mSelBox = dim;
}

void View::ctableChanged( ) {
  mCTableNew = true;
  repaint( false );
}


void View::centerOn( double x, double y ) {
  double xdif = x - (mVirDims.x + mVirDims.w / 2.0);
  double ydif = y - (mVirDims.y + mVirDims.h / 2.0);

  mLinkBox.dim.x += xdif;
  mLinkBox.dim.y += ydif;
  mVirDims.x += xdif;
  mVirDims.y += ydif;

  emit parentLinkBoxChanged( mLinkBox.dim );
  emit childVirDimsChanged( mVirDims );
  emit parentVirDimsChanged( mVirDims );
  mFullRedraw = true;
  repaint( false );
}

---

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