FigureEditor.cxx

Go to the documentation of this file.

#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#endif

// for MEMFUN1_DEFECT
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "FigureEditor.h"

#include "QtView.h"
#include "CanvasWindow.h"
#include "PickTable.h"

#include <qapplication.h>
#include <qcursor.h>
#include <qimage.h>

#if QT_VERSION < 0x040000
#include <qwmatrix.h>
#include <qpaintdevicemetrics.h>
#else
//Added by the Qt porting tool:
#include <QMouseEvent>
#include <QPixmap>
#include <QResizeEvent>
#include <qmatrix.h>
#include <q3paintdevicemetrics.h>
#endif

#include <qpainter.h>
#include <qprinter.h>
#include <qsettings.h>
#include <qstatusbar.h>

#include <algorithm>
#include <functional>

#include <cmath>
#include <cctype>

#include <cassert>

using std::abs;
using std::bind2nd;
using std::for_each;
using std::mem_fun;
using std::string;
using std::transform;
using std::vector;

namespace {
  QPrinter::PageSize indexToPageSize[] = 
    { QPrinter::A4, QPrinter::B5, QPrinter::Letter, 
      QPrinter::Legal, QPrinter::Executive,
      QPrinter::A0, QPrinter::A1, QPrinter::A2, QPrinter::A3, 
      QPrinter::A5, QPrinter::A6, QPrinter::A7, QPrinter::A8, 
      QPrinter::A9, QPrinter::B0, QPrinter::B1,
      QPrinter::B10, QPrinter::B2, QPrinter::B3, QPrinter::B4, 
      QPrinter::B6, QPrinter::B7, QPrinter::B8, QPrinter::B9, 
      QPrinter::C5E, QPrinter::Comm10E,
      QPrinter::DLE, QPrinter::Folio, QPrinter::Ledger, 
      QPrinter::Tabloid, QPrinter::Custom, QPrinter::NPageSize };

  QPrinter::Orientation indexToOrientation[] = { QPrinter::Portrait,
                                                 QPrinter::Landscape };
}

QPrinter * FigureEditor::s_printer = 0;
QString    FigureEditor::s_app_key ( "/HippoDraw/" );
QString    FigureEditor::s_registry ( "/Trolltech" );

FigureEditor::
#if QT_VERSION < 0x040000
FigureEditor ( QCanvas * c, QWidget * parent,
               const char * name, Qt::WFlags f)
  : QCanvasView ( c, parent, name, f ),
#else
FigureEditor ( Q3Canvas * c, QWidget * parent,
               const char * name, Qt::WFlags f)
  : Q3CanvasView ( c, parent, name, f ),
#endif
    m_scale_factor ( 1.0 )
{
  m_zoom_mode = false ;

  m_canvas = canvas ();
  m_canvas->setUpdatePeriod ( 30 );

  if ( s_printer == 0 )
    {
      initPrinter ();
      s_printer->setFullPage ( true );
    }
  
  calcPrinterMetrics ();
  
  m_canvas->resize ( m_apage_w, m_apage_h );

  //Printer Page margin is not visible by default
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );
  int pb = settings.readNumEntry ( s_app_key + "Canvas/Margin", 0 );
  m_printer_bounds = ( pb == 1 ) ? true : false;
 }


void
FigureEditor::
initPrinter ()
{
  s_printer = new QPrinter ( );
  
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );

  int pagesize 
    = settings.readNumEntry ( s_app_key + "Printer/PageSize", 
                              QPrinter::Letter );
  assert( pagesize < QPrinter::NPageSize );
  QPrinter::PageSize size = indexToPageSize [ pagesize ];
  
  int orientation
    = settings.readNumEntry(  s_app_key + "Printer/Orientation",
                              QPrinter::Portrait );
  assert(  orientation == 0 || orientation == 1 );
  QPrinter::Orientation orient = indexToOrientation [ orientation ];

  s_printer->setOrientation ( orient );
  s_printer->setPageSize ( size );
  s_printer->setFullPage ( true );
}

void
FigureEditor::
setAppKey ( const std::string & appkey )
{
  s_app_key = appkey.c_str();
}

void
FigureEditor::
showPrinterMargins ( bool on )
{
   
  if ( m_printer_bounds == false && on == true  ) // No margin exists. Draw 'em
    {
      m_printer_bounds = true;
      
      int height = m_canvas -> height();
      int y = 0;
      while ( y < height )
        {
          addPageMargin ( 0, y );
          y += m_apage_h;
        }
      
    }
  else if( m_printer_bounds == true && on == false ) // Margins exist delete it
    {
      m_printer_bounds = false;
      
#if QT_VERSION < 0x040000
      QCanvasItemList itemList = m_canvas -> allItems ();
      
      QValueListIterator< QCanvasItem * > iter;
      iter = itemList.begin();
            
      while( iter != itemList.end() )
        {
          QCanvasItem * item = *iter++;
          QtView * view = dynamic_cast < QtView * > ( item );
          
          if ( view == 0 )  // it is a printer page border
            {
              QCanvasRectangle * rect
                = dynamic_cast< QCanvasRectangle * >( item );
              assert( rect );
              delete rect;
            }
        }
#else
      Q3CanvasItemList itemList = m_canvas -> allItems ();
      
      Q3ValueListIterator< Q3CanvasItem * > iter;
      iter = itemList.begin();
            
      while( iter != itemList.end() )
        {
          Q3CanvasItem * item = *iter++;
          QtView * view = dynamic_cast < QtView * > ( item );
          
          if ( view == 0 )  // it is a printer page border
            {
              Q3CanvasRectangle * rect
                = dynamic_cast< Q3CanvasRectangle * >( item );
              assert( rect );
              delete rect;
            }
        }
#endif
    }
}

void
FigureEditor::
addPageMargin ( int x, int y )
{
    
  if ( m_printer_bounds == true )
    {
#if QT_VERSION < 0x040000
      QCanvasRectangle * rect 
        = new QCanvasRectangle ( x, y, m_upage_w, m_upage_h, m_canvas );
#else
      Q3CanvasRectangle * rect 
        = new Q3CanvasRectangle ( x, y, m_upage_w, m_upage_h, m_canvas );
#endif
      
      int dx = ( m_apage_w - m_upage_w ) / 2;
      int dy = ( m_apage_h - m_upage_h ) / 2;
      rect ->moveBy ( dx, dy );
      
      QColor color ( "lightGray" );
      QPen pen ( color, 1, Qt::DashLine );
      rect -> setPen ( pen );
      
      rect -> show ();
    }
}

void 
FigureEditor::
calcPrinterMetrics ()
{
  QString name = s_printer->printerName();
  if ( name.isNull() )
    {
      if( s_printer -> orientation() == QPrinter::Portrait )
        {
          m_upage_w = 720; // dimensions of letter size
          m_upage_h = 990; // HP printer in portrait mode
          m_apage_w = 816;
          m_apage_h = 1054;
        }
      else
        {
          m_upage_h = 720; // dimensions of letter size
          m_upage_w = 990; // HP printer in landscape mode
          m_apage_h = 816;
          m_apage_w = 1054;
        }
    }
  else
    {
#if QT_VERSION < 0x040000
      QPaintDeviceMetrics metrics ( s_printer );
#else
      Q3PaintDeviceMetrics metrics ( s_printer );
#endif
      int dpix = metrics.logicalDpiX ();
      int dpiy = metrics.logicalDpiY ();

      m_apage_w = metrics.widthMM ();
      m_apage_h = metrics.heightMM ();
      
      m_apage_w = static_cast < int > ( m_apage_w * dpix / 25.4 ); 
      m_apage_h = static_cast < int > ( m_apage_h * dpiy / 25.4 ); 

      if( s_printer -> orientation() == QPrinter::Landscape )
        std::swap( m_apage_w, m_apage_h );
      
      QSize margins = s_printer -> margins ();
      m_upage_w = m_apage_w - 2 * margins.width ();
      m_upage_h = m_apage_h - 2 * margins.height ();
  }
}

bool FigureEditor::isSingleItemSelected () const
{
  return ( m_selected_list.size() == 1 );
}

#if QT_VERSION < 0x040000
QCanvasItem * 
#else
Q3CanvasItem * 
#endif
FigureEditor::
selectedItem () const
{  
  if ( isSingleItemSelected() )
    {
      return m_selected_list[0];
    }
  else
    {
      return 0;
    }
}

#if QT_VERSION < 0x040000
std::vector < QCanvasItem * > & 
#else
std::vector < Q3CanvasItem * > & 
#endif
FigureEditor::
getSelectedItems ()
{
  return m_selected_list;
}

void
FigureEditor::
#if QT_VERSION < 0x040000
addSelectedItem ( QCanvasItem * item )
#else
addSelectedItem ( Q3CanvasItem * item )
#endif
{

  if ( ! item->isSelected() )
    {
      m_selected_list.push_back ( item );
      setSelectedFlags();
    }

}
 
void
FigureEditor::
#if QT_VERSION < 0x040000
removeSelectedItem ( QCanvasItem * item )
{
  if ( item->isSelected() ) {
    vector < QCanvasItem * > ::iterator last
#else
removeSelectedItem ( Q3CanvasItem * item )
{
  if ( item->isSelected() ) {
    vector < Q3CanvasItem * > ::iterator last
#endif
      = std::remove ( m_selected_list.begin(), 
                      m_selected_list.end(), item );
    m_selected_list.erase ( last, m_selected_list.end() );
    setSelectedFlags();
  }
}
 
QRect FigureEditor::getSelectedBounds () const
{
#ifdef ITERATOR_MEMBER_DEFECT
  std:: 
#endif
#if QT_VERSION < 0x040000
  vector < QCanvasItem * > ::const_iterator first 
    = m_selected_list.begin();
  QCanvasItem * item = *first++;
#else
  vector < Q3CanvasItem * > ::const_iterator first 
    = m_selected_list.begin();
  Q3CanvasItem * item = *first++;
#endif
  QRect rect = item->boundingRect();

  while ( first != m_selected_list.end() ) {
    item = *first++;
    QRect r = item->boundingRect ();
    rect |= r;
  }

  return rect;
}

double
FigureEditor::
maximumZ () const
{
#if QT_VERSION < 0x040000
  vector < QCanvasItem * > ::const_iterator first = m_items.begin();
  double max_z = (*first++) -> z ();
  while ( first != m_items.end () ) {
    QCanvasItem * item = *first++;
#else
  vector < Q3CanvasItem * > ::const_iterator first = m_items.begin();
  double max_z = (*first++) -> z ();
  while ( first != m_items.end () ) {
    Q3CanvasItem * item = *first++;
#endif
    double z = item -> z ();
    max_z = std::max ( max_z, z );
  }

  return max_z;
}

void
FigureEditor::
setUnselectedVisible ( bool yes )
{
#if QT_VERSION < 0x040000
  vector < QCanvasItem * > ::iterator first = m_items.begin();
  while ( first != m_items.end() ) {
    QCanvasItem * item = *first++;
#else
  vector < Q3CanvasItem * > ::iterator first = m_items.begin();
  while ( first != m_items.end() ) {
    Q3CanvasItem * item = *first++;
#endif
    if ( item->isSelected() ) continue;
    item->setVisible ( yes );
  }
}

void
FigureEditor::
#if QT_VERSION < 0x040000
setCollidingSelected ( const QCanvasItem * target )
{
  vector < QCanvasItem * > ::iterator first = m_items.begin ();
  while ( first != m_items.end () ) {
    QCanvasItem * item = *first++;
#else
setCollidingSelected ( const Q3CanvasItem * target )
{
  vector < Q3CanvasItem * > ::iterator first = m_items.begin ();
  while ( first != m_items.end () ) {
    Q3CanvasItem * item = *first++;
#endif
    if ( item != target ) {
      if ( item -> collidesWith ( target ) ) {
        if ( item -> selected () == false ) {
          item -> setSelected ( true );
          m_selected_list.push_back ( item );
        }
      }
    }
  }
}

void 
FigureEditor::
setSelectedItems ( bool state )
{
#ifdef ITERATOR_MEMBER_DEFECT
  std::
#endif
#if QT_VERSION < 0x040000
  vector < QCanvasItem * > ::iterator first = m_selected_list.begin();
  while ( first != m_selected_list.end() ) {
    QCanvasItem * item = *first++;
#else
  vector < Q3CanvasItem * > ::iterator first = m_selected_list.begin();
  while ( first != m_selected_list.end() ) {
    Q3CanvasItem * item = *first++;
#endif
    item->setSelected ( state );
  }
}

void FigureEditor::clearSelectedList ()
{
  if ( m_selected_list.empty () == true ) return;

  setSelectedItems ( false );

  m_selected_list.clear();
}

void
FigureEditor::
setAllSelected ( bool yes )
{
#if QT_VERSION < 0x040000
#ifdef MEMFUN1_DEFECT
  for_each ( m_items.begin(), m_items.end(),
             bind2nd ( mem_fun1 ( &QCanvasItem::setSelected ), yes ) );
#else
  for_each ( m_items.begin(), m_items.end(),
             bind2nd ( mem_fun ( &QCanvasItem::setSelected ), yes ) );
#endif
#else
#ifdef MEMFUN1_DEFECT
  for_each ( m_items.begin(), m_items.end(),
             bind2nd ( mem_fun1 ( &Q3CanvasItem::setSelected ), yes ) );
#else
  for_each ( m_items.begin(), m_items.end(),
             bind2nd ( mem_fun ( &Q3CanvasItem::setSelected ), yes ) );
#endif
#endif
  if (yes) {
     m_selected_list = m_items;
  }
}

void FigureEditor::setSelectedFlags ()
{

  // Set all selected flags to false.
  setAllSelected ( false );

  // Set all selected flags to true from m_selected_list.
#if QT_VERSION < 0x040000
  vector < QCanvasItem * > :: iterator first = m_selected_list.begin();
  while ( first != m_selected_list.end() ) {
    QCanvasItem * item = *first++;
#else
  vector < Q3CanvasItem * > :: iterator first = m_selected_list.begin();
  while ( first != m_selected_list.end() ) {
    Q3CanvasItem * item = *first++;
#endif
    item->setSelected ( true );
  }
}

void
FigureEditor::
#if QT_VERSION < 0x040000
setSelectedItem ( QCanvasItem * item )
#else
setSelectedItem ( Q3CanvasItem * item )
#endif
{

  m_selected_list.clear ();
  setSelectedFlags ();
  addSelectedItem ( item );

  double z = maximumZ ();
  item -> setZ ( z + 1.0 ); // ensures it is on top

  notifyObservers ();
}

void
FigureEditor::
#if QT_VERSION < 0x040000
ensureVisible ( const QCanvasItem * item )
#else
ensureVisible ( const Q3CanvasItem * item )
#endif
{
  QRect rect = item->boundingRect ();
  int x = 0, y = 0, w = 0, h = 0;
  rect.rect( & x, & y, & w, & h );

#if QT_VERSION < 0x040000
  QCanvasView::ensureVisible ( x, y, w, h );
#else
  Q3CanvasView::ensureVisible ( x, y, w, h );
#endif
}

void 
FigureEditor::
setLocked ( bool yes )
{
#if QT_VERSION < 0x040000
  // here
  const vector < QCanvasItem * > & items = getSelectedItems ();
  if ( items.empty () ) return; // shouldn't be called

#ifdef MEMFUN_DEFECT
  vector < QCanvasItem * >:: const_iterator first = items.begin ();
  while ( first != items.end () ) {
    QCanvasItem * item = *first++;
    item->setActive ( yes );
  }
#else
#ifdef MEMFUN1_DEFECT
    for_each ( items.begin(), items.end(),
               bind2nd ( mem_fun1 ( &QCanvasItem::setActive ), yes ) );
#else
    for_each ( items.begin(), items.end(),
               bind2nd ( mem_fun ( &QCanvasItem::setActive ), yes ) );
#endif
#endif
    // here
#else
  // here
  const vector < Q3CanvasItem * > & items = getSelectedItems ();
  if ( items.empty () ) return; // shouldn't be called

#ifdef MEMFUN_DEFECT
  vector < Q3CanvasItem * >:: const_iterator first = items.begin ();
  while ( first != items.end () ) {
    Q3CanvasItem * item = *first++;
    item->setActive ( yes );
  }
#else
#ifdef MEMFUN1_DEFECT
    for_each ( items.begin(), items.end(),
               bind2nd ( mem_fun1 ( &Q3CanvasItem::setActive ), yes ) );
#else
    for_each ( items.begin(), items.end(),
               bind2nd ( mem_fun ( &Q3CanvasItem::setActive ), yes ) );
#endif
#endif
    // here
#endif
}

void
FigureEditor::
#if QT_VERSION < 0x040000
placeGraphOnSelected ( QCanvasRectangle * view )
#else
placeGraphOnSelected ( Q3CanvasRectangle * view )
#endif
{

  if ( !isSingleItemSelected() ) return;

#if QT_VERSION < 0x040000
  QCanvasItem * sel_item = selectedItem ();
#else
  Q3CanvasItem * sel_item = selectedItem ();
#endif
  QRect rect = sel_item->boundingRect ();

  view->setX ( rect.x() );
  view->setY ( rect.y() );
  view->setSize ( rect.width(), rect.height () );

  view->setCanvas ( m_canvas );
  m_items.push_back ( view );
  view->setSelected ( true );

  view->show ();
}

void FigureEditor::contentsMousePressEvent ( QMouseEvent* e )
{
  // If both Shift and Control buttons are down, then error, do nothing.
  
#if QT_VERSION < 0x040000
  if ( e->state() == Qt::ShiftButton && 
       e->state() == Qt::ControlButton ) return;
#else
  if ( e->state() == Qt::ShiftModifier && 
       e->state() == Qt::ControlModifier ) return;
#endif

  QPoint p = inverseWorldMatrix().map(e->pos());
#if QT_VERSION < 0x040000
  QCanvasItemList l = m_canvas->collisions ( p );
  QCanvasItemList::Iterator it = l.begin(); // for MS VC++
  QCanvasItem * selItem = 0;  
#else
  Q3CanvasItemList l = m_canvas->collisions ( p );
  Q3CanvasItemList::Iterator it = l.begin(); // for MS VC++
  Q3CanvasItem * selItem = 0;  
#endif
  for ( ; it!=l.end(); ++it) {
    selItem = *it;
#if QT_VERSION < 0x040000
    vector < QCanvasItem * > ::const_iterator first 
#else
    vector < Q3CanvasItem * > ::const_iterator first 
#endif
      = std::find ( m_items.begin (), m_items.end (), selItem );
    if ( first != m_items.end () ) { // only accept views
      moving_start = p;
      zoom_start = p;
      break;
    }
    selItem = 0;
  }

  if ( !selItem ) 
    {

      // There was no display where the click occurred. Ignore the click if
      // its control click, else clear the selected list.
#if QT_VERSION < 0x040000
      if ( e->state() != Qt::ControlButton )
#else
      if ( e->state() != Qt::ControlModifier )
#endif
        {
          m_selected_list.clear();
          setSelectedFlags();
          whereClicked();
          return;
        }
      else
        {
          return;
        }
    }
    
  // If control key is down, then add the current item to the vector, else
  // clear the vector and then add the current item to the vector.

#if QT_VERSION < 0x040000
  if ( e->state() == Qt::ShiftButton )
#else
  if ( e->state() == Qt::ShiftModifier )
#endif
    {
      if ( selItem -> isSelected () ) {
        removeSelectedItem ( selItem );
      }
      else {
        addSelectedItem ( selItem );      
      }
    }
#if QT_VERSION < 0x040000
  else if ( e->state() == Qt::ControlButton )
#else
  else if ( e->state() == Qt::ControlModifier )
#endif
    {
      m_selected_list.clear();
      setSelectedFlags();
      addSelectedItem ( selItem );

      controlMousePressEvent (); // handled by derived class

      whereClicked ();
    }

  else
    { // neither shift nore control
      setSelectedItem ( selItem );
      whereClicked();
    }

  if ( e->button() == Qt::RightButton ) {
    contentsMouseMoveEvent ( e, 0 );
  }

}

void FigureEditor::whereClicked ( )
{

  m_whereClicked = invalid;
  
  if ( !isSingleItemSelected() ) return;
  
  m_whereClicked = none;

#if QT_VERSION < 0x040000
  QCanvasRectangle * rect 
    = dynamic_cast <QCanvasRectangle *> ( selectedItem() );
#else
  Q3CanvasRectangle * rect 
    = dynamic_cast <Q3CanvasRectangle *> ( selectedItem() );
#endif
  
  // The margin around the point where a click will be registered.
  int clickMargin = 10;

  QPoint p = moving_start;

  if ( ( p.x() < rect->x() + clickMargin ) &&
       ( p.y() < rect->y() + clickMargin ) )
    {
      m_whereClicked = upper_left;
    }

  if ( ( p.x() < ( rect->x() + (rect->width() / 2) + clickMargin ) ) &&
       ( p.x() > ( rect->x() + (rect->width() / 2) - clickMargin ) ) &&
       ( p.y() < rect->y() + clickMargin ) )
    {
      m_whereClicked = upper_middle;
    }

  if ( ( p.x() > ( rect->x() + rect->width() - clickMargin ) ) &&
       ( p.y() < rect->y() + clickMargin ) )
    {
      m_whereClicked = upper_right;
    }

  if ( ( p.x() < rect->x() + clickMargin ) &&
       ( p.y() < ( rect->y() + (rect->height() / 2) + clickMargin ) ) &&
       ( p.y() > ( rect->y() + (rect->height() / 2) - clickMargin ) ) )
    {
      m_whereClicked = middle_left;
    }

  if ( ( p.x() > ( rect->x() + rect->width() - clickMargin ) ) &&
       ( p.y() < ( rect->y() + (rect->height() / 2) + clickMargin ) ) &&
       ( p.y() > ( rect->y() + (rect->height() / 2) - clickMargin ) ) )
    {
      m_whereClicked = middle_right;
    }

  if ( ( p.x() < rect->x() + clickMargin ) &&
       ( p.y() > rect->y() + rect->height() - clickMargin ) )
    {
      m_whereClicked = lower_left;
    }

  if ( ( p.x() < ( rect->x() + (rect->width() / 2) + clickMargin ) ) &&
       ( p.x() > ( rect->x() + (rect->width() / 2) - clickMargin ) ) &&
       ( p.y() > rect->y() + rect->height() - clickMargin ) )
    {
      m_whereClicked = lower_middle;
    }
  
  if ( ( p.x() > ( rect->x() + rect->width()  - clickMargin ) ) &&
       ( p.y() > ( rect->y() + rect->height() - clickMargin ) ) )
    {
      m_whereClicked = lower_right;
    }

}

void
FigureEditor::
#if QT_VERSION < 0x040000
removeFromItemList ( QCanvasItem * item )
{
  vector < QCanvasItem * > ::iterator last 
#else
removeFromItemList ( Q3CanvasItem * item )
{
  vector < Q3CanvasItem * > ::iterator last 
#endif
    = std::remove ( m_items.begin (), m_items.end (), item );
  m_items.erase ( last, m_items.end () );
}

void
FigureEditor::
#if QT_VERSION < 0x040000
remove ( QCanvasItem * item )
#else
remove ( Q3CanvasItem * item )
#endif
{
  m_selected_list.clear();
  removeFromItemList ( item );

  delete item;
}

void FigureEditor::clear()
{
#if QT_VERSION < 0x040000
  vector < QCanvasItem * >:: iterator it = m_items.begin();
#else
  vector < Q3CanvasItem * >:: iterator it = m_items.begin();
#endif
  for ( ; it != m_items.end(); ++it ) {
    if ( *it ) delete *it;
  }

  m_items.clear();
  m_selected_list.clear();
}

void FigureEditor::contentsMouseMoveEvent ( QMouseEvent * e, double aspect )
{
  if ( m_whereClicked == invalid )  return;
  if ( !isSingleItemSelected() ) return;

  QPoint p = inverseWorldMatrix().map(e->pos());

#if QT_VERSION < 0x040000
  QCanvasItem * selItem = selectedItem();
  QCanvasRectangle * rect 
    = dynamic_cast <QCanvasRectangle *> ( selItem );
#else
  Q3CanvasItem * selItem = selectedItem();
  Q3CanvasRectangle * rect 
    = dynamic_cast <Q3CanvasRectangle *> ( selItem );
#endif
  
  if ( e->button() == Qt::RightButton ||
       e->state() == Qt::RightButton ) {
    
    // Get a handle on the Canvas Window.

#if QT_VERSION < 0x040000
    CanvasWindow * cw = dynamic_cast < CanvasWindow * > ( parentWidget() );
    QStatusBar * sb = cw->statusBar();
#else
//     QStatusBar * sb = cw->statusBar(); Need to get
//     AbsCanvasWindow to inherti from QMainWindo
#endif
    if ( ( p.x() >= rect->x() ) &&
         ( p.x() <= rect->x() + rect->width() ) &&
         ( p.y() >= rect->y() ) &&
         ( p.y() <= rect->y() + rect->height() ) ) {
      
      QtView * qtview = dynamic_cast < QtView * > ( selItem );

      vector < double > picked;
      qtview -> fillPickedPoint ( p.x(), p.y(), picked );
      if ( picked.empty () ) return;

      unsigned int size = picked.size();
      double datax = picked[1];
      double datay = picked[2]; // scaled if needed
      double dataz = 0.0;
      if ( size >= 4 ) {
        dataz = picked[3];
      }

      double unscaledDataX = picked[1];
      double unscaledDataY = picked[2];
      if ( abs ( picked[0] - 1.0 ) < 0.5 )  unscaledDataY = picked[3];
      

      qtview->setCrossX ( unscaledDataX );
      qtview->setCrossY ( unscaledDataY );
      qtview->setShowCrossHairs ( true );
      const QCursor cursor ( Qt::CrossCursor );
      QApplication::setOverrideCursor ( cursor, true );
      qtview->update(0);
      
      QString qstr = QString 
        ( "Coordinates are : ( %1, %2, %3 )" )
        .arg ( datax )
        .arg ( datay )
        .arg ( dataz );
      
#if QT_VERSION < 0x040000
      sb->message ( qstr );
#endif
    }
    
    return;
  
  }

  switch ( m_whereClicked )
    {
          
    case none:  
      if (! (getZoomMode() ) ){
      selItem->moveBy(p.x() - moving_start.x(),
              p.y() - moving_start.y());
      }
      break;

    case upper_left:

      if ( aspect > 0 )
        {
          // Follow Y. Fixed Point is lower right.

          double new_h = rect->height() + moving_start.y() - p.y();

          double new_w = aspect * ( new_h );

          rect->setY ( rect->y() + rect->height() - new_h );
          
          rect->setX ( rect->x() + rect->width() - new_w );
          
          rect->setSize ( static_cast < int > ( new_w ),
                          static_cast < int > ( new_h ) );                
        }
      
      else
        {
          rect->setX ( p.x() );
          rect->setY ( p.y() );
          rect->setSize ( rect->width() + moving_start.x() - p.x(),
                          rect->height() + moving_start.y() - p.y() );
        }         

      if ( rect->width() < 0 && rect->height() < 0 )
        {
          rect->setSize ( 0,0 );
          m_whereClicked = lower_right;
          rect->setEnabled ( true );
          break;
        }
          
      if ( rect->width() < 0 )
        {
          rect->setSize ( 0, rect->height() );
          m_whereClicked = upper_right;
          rect->setEnabled ( true );
          break;
        }
          
      if ( rect->height() < 0 )
        {
          rect->setSize ( rect->width(), 0 );
          m_whereClicked = lower_left;
          rect->setEnabled ( true );
          break;
        }

      rect->setEnabled ( true );
      break;
        
    case upper_middle:
      
      rect->setY ( p.y() );

      if ( aspect > 0 )
        {
          double new_w = aspect * ( rect->height() + moving_start.y() 
                                    - p.y() );
          
          double new_x = rect->x() - ( new_w - rect->width() ) / 2.0;

          rect->setX ( new_x );

          rect->setSize ( static_cast< int > ( new_w ),
                          rect->height() + moving_start.y() - p.y() );
        }
      else
        {
          rect->setSize ( rect->width(),
                          rect->height() + moving_start.y() - p.y() );
        }

      if ( rect->height() < 0 )
        {
          rect->setSize ( rect->width(), 0 );
          m_whereClicked = lower_middle;
          rect->setEnabled ( true );
          break;
        }
          
      rect->setEnabled ( true );
      break;
        
    case upper_right:
      
      if ( aspect > 0 )
        {
          // Follow Y. Fixed Point is lower left.

          double new_h = rect->height() + moving_start.y() - p.y();

          double new_w = aspect * ( new_h );

          rect->setY ( rect->y() + rect->height() - new_h );
          
          rect->setSize ( static_cast < int > ( new_w ),
                          static_cast < int > ( new_h ) );                
        }

      else
        {
          rect->setY ( p.y() );
          rect->setSize ( rect->width() + p.x() - moving_start.x(),
                          rect->height() + moving_start.y() - p.y() );
        }         

      if ( rect->width() < 0 && rect->height() < 0 )
        {
          rect->setSize ( 0,0 );
          m_whereClicked = lower_left;
          rect->setEnabled ( true );
          break;
        }
          
      if ( rect->width() < 0 )
        {
          rect->setSize ( 0, rect->height() );
          m_whereClicked = upper_left;
          rect->setEnabled ( true );
          break;
        }
          
      if ( rect->height() < 0 )
        {
          rect->setSize ( rect->width(), 0 );
          m_whereClicked = lower_right;
          rect->setEnabled ( true );
          break;
        }
          
      rect->setEnabled ( true );
      break;
        
    case middle_left:
      
      rect->setX ( p.x() );

      if ( aspect > 0 )
        {
          double new_h = ( rect->width() + moving_start.x() 
                           - p.x() ) / aspect;

          double new_y = rect->y() - ( new_h - rect->height() ) / 2.0;

          rect->setY ( new_y );

          rect->setSize ( rect->width() + moving_start.x() - p.x(),
                          static_cast < int > ( new_h ) );
        }
      else
        {
          rect->setSize ( rect->width() + moving_start.x() - p.x(),
                          rect->height() );
        }
          
      if ( rect->width() < 0 )
        {
          rect->setSize ( 0, rect->height() );
          m_whereClicked = middle_right;
          rect->setEnabled ( true );
          break;
        }
          
      rect->setEnabled ( true );
      break;
        
    case middle_right:
          
      if ( aspect > 0 )
        {
          double new_h = ( rect->width() + p.x() 
                           - moving_start.x() ) / aspect;

          double new_y = rect->y() - ( new_h - rect->height() ) / 2.0;

          rect->setY ( new_y );

          rect->setSize ( rect->width() + p.x() - moving_start.x(),
                          static_cast < int > ( new_h ) );
        }
      else
        {
          rect->setSize ( rect->width() + p.x() - moving_start.x(),
                          rect->height() );
        }

      if ( rect->width() < 0 )
        {
          rect->setSize ( 0, rect->height() );
          m_whereClicked = middle_left;
          rect->setEnabled ( true );
          break;
        }
          
      rect->setEnabled ( true );
      break;
        
    case lower_left:
      
      if ( aspect > 0 )
        {

          // Follow Y. Fixed point is upper right.

          double new_w = aspect * ( rect->height() + p.y() 
                                    - moving_start.y() );
          
          rect->setX ( rect->x() + rect->width() - new_w );

          rect->setSize ( static_cast < int > ( new_w ),
                          rect->height() + p.y() - moving_start.y() );
        }
         
      else
        {
          rect->setX ( p.x() );
          rect->setSize ( rect->width() + moving_start.x() - p.x(),
                          rect->height() + p.y() - moving_start.y() );
        }

      if ( rect->width() < 0 && rect->height() < 0 )
        {
          rect->setSize ( 0,0 );
          m_whereClicked = upper_right;
          rect->setEnabled ( true );
          break;
        }
          
      if ( rect->width() < 0 )
        {
          rect->setSize ( 0, rect->height() );
          m_whereClicked = lower_right;
          rect->setEnabled ( true );
          break;
        }
          
      if ( rect->height() < 0 )
        {
          rect->setSize ( rect->width(), 0 );
          m_whereClicked = upper_left;
          rect->setEnabled ( true );
          break;
        }         
          
      rect->setEnabled ( true );
      break;
        
    case lower_middle:
      
      if ( aspect > 0 )
        {
          double new_w = aspect * ( rect->height() + p.y() 
                                    - moving_start.y() );

          double new_x = rect->x() - ( new_w - rect->width() ) / 2.0;

          rect->setX ( new_x );

          rect->setSize ( static_cast < int > ( new_w ),
                          rect->height() + p.y() - moving_start.y() );
        }
      else
        {
          rect->setSize ( rect->width(),
                          rect->height() + p.y() - moving_start.y() );
        }

      if ( rect->height() < 0 )
        {
          rect->setSize ( rect->width(), 0 );
          m_whereClicked = upper_middle;
          rect->setEnabled ( true );
          break;
        }         

      rect->setEnabled ( true );
      break;
        
    case lower_right:
      
      if ( aspect > 0 )
        {

          // Follow Y.
          
          double new_w = aspect * ( rect->height() + p.y() 
                                    - moving_start.y() );
          
          rect->setSize ( static_cast < int > ( new_w ),
                          rect->height() + p.y() - moving_start.y() );
        }

      else
        {
          rect->setSize ( rect->width() + p.x() - moving_start.x(),
                          rect->height() + p.y() - moving_start.y());
        }

      if ( rect->width() < 0 && rect->height() < 0 )
        {
          rect->setSize ( 0,0 );
          m_whereClicked = upper_left;
          rect->setEnabled ( true );
          break;
        }
          
      if ( rect->width() < 0 )
        {
          rect->setSize ( 0, rect->height() );
          m_whereClicked = lower_left;
          rect->setEnabled ( true );
          break;
        }
          
      if ( rect->height() < 0 )
        {
          rect->setSize ( rect->width(), 0 );
          m_whereClicked = upper_right;
          rect->setEnabled ( true );
          break;
        }

      rect->setEnabled ( true );
      break;
          
    default:

      break;
        
    }
  
  moving_start = p;
  
  m_canvas->update();

}

void
FigureEditor::
#if QT_VERSION < 0x040000
placeGraph ( QCanvasRectangle * item )
#else
placeGraph ( Q3CanvasRectangle * item )
#endif
{
  item -> setX ( 0 );
  item -> setY ( 0 );

  int margin_x = ( m_apage_w - m_upage_w ) / 2;
  int margin_y = ( m_apage_h - m_upage_h ) / 2;

  if ( item -> x () < margin_x ) item -> setX ( margin_x + 1 );
  if ( item -> y () < margin_y ) item -> setY ( margin_y + 1 );

  if ( m_items.empty () ) return;

  double deltax = 1.05 * item -> width ();
  double deltay = 1.05 * item -> height ();

  while ( true ) {
    QRect brect = item->boundingRect ();
    int top = brect.top () / m_apage_h;
    int bot = brect.bottom () / m_apage_h;
    if ( top != bot  ) { // across page boundary
      int new_y = bot * m_apage_h;
      new_y += ( m_apage_h - m_upage_h ) / 2;
      item->setY ( new_y ); // beginning next actual page
    }

#if QT_VERSION < 0x040000
    vector < QCanvasItem * >:: iterator it = m_items.begin();
#else
    vector < Q3CanvasItem * >:: iterator it = m_items.begin();
#endif
    bool collides = false;

    for ( ; it != m_items.end(); ++it ) {
      if ( (*it)->collidesWith ( item ) ) {
        collides = true;
        break;
      }
    }

    if ( !collides ) break;

    if ( item -> x() + deltax + item -> width () < m_apage_w - margin_x ) {
      item -> moveBy ( deltax, 0 ); // move across
    }
    else {
      item -> setX ( margin_x + 1 );
      item -> moveBy ( 0, deltay ); // move down
    }

  } // while true

}

void
FigureEditor::
#if QT_VERSION < 0x040000
add ( QCanvasItem * item ) 
#else
add ( Q3CanvasItem * item ) 
#endif
{ 
  resizeCanvasToFit ( item );
  
  item->setCanvas ( m_canvas );
  m_items.push_back ( item );
  item->setSelected ( false );

  item->show ();
}

void
FigureEditor::
#if QT_VERSION < 0x040000
paste ( QCanvasItem * item )
#else
paste ( Q3CanvasItem * item )
#endif
{
  add ( item );

#if QT_VERSION < 0x040000
  QCanvasItemList items = item->collisions ( true );
#else
  Q3CanvasItemList items = item->collisions ( true );
#endif
  if ( items.count() > 0 ) {
    item->moveBy ( 10., 10. );
  }
}

void
FigureEditor::
#if QT_VERSION < 0x040000
resizeCanvasToFit ( QCanvasItem * item )
#else
resizeCanvasToFit ( Q3CanvasItem * item )
#endif
{
  QRect brect = item->boundingRect ();
  QPoint p = brect.bottomRight ();
  if ( ! m_canvas->onCanvas ( p ) )
    {
      int new_w = m_canvas->width ();
      int old_h = m_canvas->height();
      int new_h = old_h + m_apage_h;
      m_canvas->resize ( new_w, new_h );
      addPageMargin ( 0, old_h );
  }
}

void
FigureEditor::
scaleBy ( double factor )
{
  m_apage_w = static_cast < int > ( factor * m_apage_w );
  m_apage_h = static_cast < int > ( factor * m_apage_h );
  m_upage_w = static_cast < int > ( factor * m_upage_w );
  m_upage_h = static_cast < int > ( factor * m_upage_h );
  
  m_canvas -> resize ( m_apage_w, m_apage_h );
  resizeContents ( m_apage_w, m_apage_h );
  
  m_scale_factor = factor;
  
  if( m_printer_bounds == true )
    {
      showPrinterMargins ( false ); // Delete old ones ( if any    )
      showPrinterMargins ( true );  // Redraw new ones ( if needed )
    }
}

void
FigureEditor::
viewZoomIn ()
{
#if QT_VERSION < 0x040000
    QWMatrix matrix = worldMatrix ();
#else
    QMatrix matrix = worldMatrix ();
#endif
    matrix.scale( 4./3., 4./3. );

    setWorldMatrix ( matrix );
}

void
FigureEditor::
viewZoomOut ()
{
#if QT_VERSION < 0x040000
    QWMatrix matrix = worldMatrix ();
#else
    QMatrix matrix = worldMatrix ();
#endif
    matrix.scale( 3./4., 3./4. );

    setWorldMatrix ( matrix );
}

void
FigureEditor::
viewZoomReset ()
{
#if QT_VERSION < 0x040000
  QWMatrix matrix = worldMatrix ();
#else
  QMatrix matrix = worldMatrix ();
#endif
  matrix.reset();

  setWorldMatrix ( matrix );
}

void
FigureEditor::
savePrinterSettings ()
{
  QSettings settings;
  settings.insertSearchPath ( QSettings::Windows, s_registry );

  QPrinter::PageSize page_size = s_printer -> pageSize ();
  settings.writeEntry ( s_app_key + "Printer/PageSize", page_size );

}

void
FigureEditor::
setPrinterSettings ()
{
  bool yes = s_printer -> setup ( this );
  if ( yes == false ) return;

  savePrinterSettings ();
}

void
FigureEditor::
print ()
{
  bool yes = s_printer->setup ( this );
  if ( yes == false ) return;

  print ( s_printer );
}

void
FigureEditor::
print ( const std::string & filename )
{
  const QString name = filename.c_str();
  s_printer -> setOutputFileName ( name );
  s_printer -> setOutputToFile ( true );

  print ( s_printer );
}

void
FigureEditor::
print ( QPrinter * printer )
{
  calcPrinterMetrics ();

  setSelectedItems ( false ); // hide border
  QPainter painter;
  painter.begin ( printer );
  double scale = 1.0 / m_scale_factor;
  painter.scale ( scale, scale );
  int page_y = 0;
  while ( page_y < m_canvas->height() ) {
    const QRect clip ( 0, page_y, m_upage_w, m_upage_h );
#if QT_VERSION < 0x040000
    QCanvasItemList items = m_canvas->collisions ( clip );
#else
    Q3CanvasItemList items = m_canvas->collisions ( clip );
#endif

    if ( items.empty () ) {
      page_y += m_apage_h;
      painter.translate ( 0, - m_apage_h );
      continue;
    }
    if ( page_y != 0 ) printer->newPage();
    page_y += m_apage_h;

    bool dbuf = false;

    m_canvas->drawArea ( clip, & painter, dbuf );

    painter.translate ( 0, - m_apage_h );
  }
  painter.end();
  setSelectedItems ( true ); // hide border
}

void
FigureEditor::
resizeEvent ( QResizeEvent * e )
{
  const QSize & w_size = e->size();

  // need to specify type for vs.net compiler
  int new_w = std::max<int> ( w_size.width (),  m_canvas->width () );
  int new_h = std::max<int> ( w_size.height (), m_canvas->height () );

  m_canvas->resize ( new_w, new_h );

  updateScrollBars ();
}

void
FigureEditor::
addPage ()
{
  int old_y = m_canvas->height ();
  m_canvas->resize ( m_canvas->width(), old_y + m_apage_h );
  addPageMargin ( 0, old_y );

  updateScrollBars ();
}

void 
FigureEditor::
saveSelectedAsPixmap ( const std::string & filename )
{
  QRect rect = getSelectedBounds ();
  setSelectedItems ( false ); // hide for pixmap
  saveAreaAsPixmap ( rect, filename );
}

void
FigureEditor::
saveAreaAsPixmap ( const QRect & rect, const std::string & filename )
{
  QPixmap pixmap ( rect.width(), rect.height() );
  QPainter painter;

  painter.begin ( &pixmap );
  painter.translate ( -rect.x(), -rect.y() );
  m_canvas->drawArea ( rect, & painter );
  painter.end ();

  setSelectedItems ( true ); // restore

  QString fn ( filename.c_str() );
  string::size_type i = filename.find_last_of ( '.' );
  string suffix ( filename.substr ( i + 1 ) );
  transform ( suffix.begin(), suffix.end(),
              suffix.begin(), toupper );
  if ( suffix == "JPG" ) suffix = "JPEG";
  pixmap.save ( fn, suffix.c_str() );
}


void 
FigureEditor::
setZoomMode ( bool flag )
{
  m_zoom_mode = flag;
  if ( flag )
      QApplication::setOverrideCursor( QCursor ( Qt::CrossCursor ) );
  else
      QApplication::setOverrideCursor( QCursor ( Qt::ArrowCursor ) );
}




bool 
FigureEditor::
getZoomMode ( ) const
{
  return m_zoom_mode;
}

---