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 "QtGroupView.h"
#include "CanvasWindow.h"
#include "PickTable.h"
#include "plotters/PlotterBase.h"

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

#if QT_VERSION < 0x040000
#include <qdragobject.h>
#include <qwmatrix.h>
#include <qpaintdevicemetrics.h>
#else
// Added by the Qt porting tool:
#include <q3dragobject.h>
#include <QtGui/QMouseEvent>
#include <QtGui/QPixmap>
#include <QtGui/QResizeEvent>
#include <QtGui/QPrintDialog>
#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;


static 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 };

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

static  QPrinter::ColorMode indexToColorMode[] = { QPrinter::GrayScale,
                                                   QPrinter::Color };

using namespace hippodraw;

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_printer_bounds ( false ),
    m_ignore_margin ( false ),
    m_rightItem ( 0 )
{
  m_zoom_mode = false ;

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

  if ( s_printer == 0 )
    {
      initPrinter ();
    }
  
  calcPrinterMetrics ( s_printer );
  
  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 );
  bool yes = ( pb == 1 ) ? true : false;
  showPrinterMargins ( yes );
 }


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

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

  const int color
    = settings.readNumEntry( s_app_key + "Printer/ColorMode",
                             QPrinter::Color );
  assert( color == 0 || color == 1 );
  QPrinter::ColorMode colorMode = indexToColorMode[color];

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

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 ( QPaintDevice * device )
{
  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 ( device );
#else
      Q3PaintDeviceMetrics metrics ( device );
#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
{
  /* This is only used to determine if the view is a text view */
  QtView* view = NULL;

#if QT_VERSION < 0x040000
  vector < QCanvasItem * > ::const_iterator first = m_items.begin();
  double max_z = (*first) -> z ();
  
  /* Get z()-100 for text plotter */
  view = dynamic_cast<QtView*> (*first);
  if (view && view->isTextView())
    max_z -= 100;
  
  first++;
  
  
  while ( first != m_items.end () ) {
    QCanvasItem * item = *first;
#else
  vector < Q3CanvasItem * > ::const_iterator first = m_items.begin();
  double max_z = (*first) -> z ();

  /* z()-100 for text */
  view = dynamic_cast<QtView*> (*first);
  if (view && view->isTextView())
    max_z -= 100;
  
  first++;

  while ( first != m_items.end () ) {
    Q3CanvasItem * item = *first;
#endif
    double z = item -> z ();

    /* z()-100 for text */
    view = dynamic_cast<QtView*> (item);
    if (view && view->isTextView())
      z -= 100;

    
    first++;
    
    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::
customEvent ( QCustomEvent * event )
{
    CanvasEvent * ce = dynamic_cast < CanvasEvent * > ( event );
    if (  ce != 0 ) {
#if QT_VERSION < 0x040000
        const QCanvasItem * item = ce -> item ();
#else
        const Q3CanvasItem * item = ce -> item ();
#endif
        makeVisible ( item );
    }
}
void
  FigureEditor::
#if QT_VERSION < 0x040000
  makeVisible ( const QCanvasItem * item ) 
#else
  makeVisible ( const Q3CanvasItem * item )
#endif
{
  if ( item != 0 ) {
    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::
#if QT_VERSION < 0x040000
setSelectedItem ( QCanvasItem * item )
#else
setSelectedItem ( Q3CanvasItem * item )
#endif
{

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

  double z = maximumZ ();

  /* SetZ for text plotter */
  const QtView* view = dynamic_cast<const QtView*> (item);
  if (view && view->isTextView())
    item->setZ( z + 101.0);   // ensures it is on top of other text plotters
  else
    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
{
#ifdef _MSC_VER
CanvasEvent * event = new CanvasEvent ( item );
qApp -> postEvent ( this, event );
#else
 makeVisible ( item );
#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 -> modifiers () & Qt::ShiftModifier ) &&
       ( e -> modifiers() & 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
      m_moving_start = p;
      m_zoom_start = p;
      break;
    }
    else {
      selItem = 0;
    }
  }

  if ( selItem == 0 )  {
      // 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 -> modifiers() & Qt::ControlModifier ) == 0 ) {
#endif
        m_selected_list.clear();
        setSelectedFlags();
        whereClicked();
        m_rightItem = 0;
        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 (e->button() == Qt::LeftButton)
    {

      // Shift click is used to select multiple items when not in zoom mode.
      
#if QT_VERSION < 0x040000
      if (( e->state() == Qt::ShiftButton ) && (!getZoomMode()))
#else
      if (( e -> modifiers () & Qt::ShiftModifier ) &&( !getZoomMode()))
#endif
    {
      if ( selItem -> isSelected () ) {
        removeSelectedItem ( selItem );
      }
      else {
        addSelectedItem ( selItem );      
      }
    }
#if QT_VERSION < 0x040000
  else if ( e->state() == Qt::ControlButton )
#else
  else if ( e -> modifiers() & Qt::ControlModifier )
#endif
    {
      m_selected_list.clear();
      setSelectedFlags();
      addSelectedItem ( selItem );

      controlMousePressEvent (); // handled by derived class

      whereClicked ();
    }

  else
    { // neither shift nor control
#if QT_VERSION < 0x040000
      vector < QCanvasItem * > ::const_iterator first 
#else
      vector < Q3CanvasItem * > ::const_iterator first 
#endif
        = std::find ( m_selected_list.begin (), m_selected_list.end (),
                      selItem );
      // Selected plot. Drag to move or click to select signal plot.
      if ( first != m_selected_list.end () )  
        {
          m_mouse_down = p;
          m_isMouseDown = true;
          m_preSelected = selItem;
          whereClicked();
          return;
        }

      // Not selected. Select the plot when mouse down.
      else 
        {  
          setSelectedItem ( selItem );
          whereClicked();
        }
    }
    }
  

  if ( e->button() == Qt::RightButton ||
       e->state() == Qt::RightButton )
  {
    double z = maximumZ ();

    /* SetZ for text plotter */
    const QtView* view = dynamic_cast<const QtView*> (selItem);
    if (view && view->isTextView())
      selItem->setZ( z + 101.0);   // ensures it is on top of other text plotters
    else
      selItem -> setZ ( z + 1.0 ); // ensures it is on top
    
    m_rightItem = selItem; 
  }
}



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 = m_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
addToItemList ( QCanvasItem * item )
#else
addToItemList ( Q3CanvasItem * item )
#endif
{
  item->setCanvas ( m_canvas );
  m_items.push_back ( item );
}

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

  //item->hide();
  //m_canvas->update();
  delete item;
}

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

  item->hide();
  //m_canvas->update();
  //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 )
{
  // Zoom mode is processed in CanvasView class.
  if ( getZoomMode() ) return;

  // Right button movement is processed by CanvasView class.

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

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

#if QT_VERSION < 0x040000
  QCanvasItem * selItem = selectedItem();
  QCanvasRectangle * rect 
    = dynamic_cast <QCanvasRectangle *> ( selItem );
#else
  Q3CanvasItem * selItem = selectedItem();
  Q3CanvasRectangle * rect 
    = dynamic_cast <Q3CanvasRectangle *> ( selItem );
#endif
  
  QtView * view = dynamic_cast < QtView * > ( selItem );
  QtGroupView * gv = dynamic_cast < QtGroupView * > (selItem);

  float p_x = p.x ();
  float p_y = p.y ();

  float d_x = m_moving_start.x() - p_x;
  float d_y = m_moving_start.y() - p_y;

  float new_x = rect -> x();
  float new_y = rect -> y();
  float new_w = rect -> width ();
  float new_h = rect -> height ();

  switch ( m_whereClicked )
    {
    
          
    case none:  // Move the selected view and all target text plotters
      if ( ! (getZoomMode() ) ) {
        if (view) movePlotterWithText(selItem, p.x()-m_moving_start.x(), p.y()-m_moving_start.y());
        if (gv) selItem->moveBy(p.x()-m_moving_start.x(), p.y()-m_moving_start.y());
      }
      break;

    case upper_left:

      new_x = p_x;
      new_y = p_y;
      new_w += d_x;
      new_h += d_y;
      if ( aspect > 0 ) {
        new_h += d_x;
        new_w = new_h * aspect;
      }
      new_w = std::max ( new_w, 20.0f );
      new_h = std::max ( new_h, 20.0f );

      if (view) view -> setDrawRect ( new_x, new_y, new_w, new_h );
      if (gv)  gv -> setDrawRect ( new_x, new_y, new_w, new_h );

      rect->setEnabled ( true );
      break;
        
    case upper_middle:

      // new_x unchanged      
      new_y = p_y;
      // new_w = unchanged
      new_h += d_y;

      if ( aspect > 0 ) {
          new_w += aspect * d_y;          
          new_x -= 0.5 * aspect * d_y;
      }

      new_w = std::max ( new_w, 20.0f );
      new_h = std::max ( new_h, 20.0f );

      if (view) view -> setDrawRect ( new_x, p_y, new_w, new_h );
      if (gv)  gv -> setDrawRect ( new_x, p_y, new_w, new_h );

      rect->setEnabled ( true );
      break;
        
    case upper_right:
      
      // new_x unchanged
      new_y = p_y;
      new_w -= d_x;
      new_h += d_y;
      if ( aspect > 0 ) {
          new_h -= d_x;
          new_w = aspect * new_h;
      }

      new_w = std::max ( new_w, 20.0f );
      new_h = std::max ( new_h, 20.0f );

      if (view) view -> setDrawRect ( new_x, new_y, new_w, new_h );
      if (gv) gv->setDrawRect ( new_x, new_y, new_w, new_h );
          
      rect->setEnabled ( true );
      break;
        
    case middle_left:

      new_x = p_x;
      // new_y unchanged
      new_w += d_x;
      // new_h unchanged

      if ( aspect > 0 ) {
          new_h += d_x / aspect;
          new_w = new_h * aspect;
      }

      new_w = std::max ( new_w, 20.0f );
      new_h = std::max ( new_h, 20.0f );

      if (view) view -> setDrawRect ( new_x, new_y, new_w, new_h );
      if (gv) gv -> setDrawRect ( new_x, new_y, new_w, new_h );
          
      rect->setEnabled ( true );
      break;
        
    case middle_right:

      // new_x unchanged
      // new_y unchanged
      new_w -= d_x;
      // new_h unchanged

      if ( aspect > 0 ) {
        new_h -= d_x / aspect;
        new_w = new_h * aspect;
      }

      new_w = std::max ( new_w, 20.0f );
      new_h = std::max ( new_h, 20.0f );

      if (view) view -> setDrawRect ( new_x, new_y, new_w, new_h );
      if (gv) gv -> setDrawRect ( new_x, new_y, new_w, new_h );

      rect->setEnabled ( true );
      break;
        
    case lower_left:

      new_x = p_x;
      // new_y unchanged
      new_w += d_x;
      new_h-= d_y;
      
      if ( aspect > 0 ) {
          new_h += d_x;
          new_y -= d_x;
          new_w = new_h * aspect;
      }
         
      new_w = std::max ( new_w, 20.0f );
      new_h = std::max ( new_h, 20.0f );

      if (view) view -> setDrawRect ( new_x, new_y, new_w, new_h );
      if (gv) gv -> setDrawRect ( new_x, new_y, new_w, new_h );

      rect->setEnabled ( true );
      break;
        
    case lower_middle:
     
      // new_x unchanged
      // new_y unchanged
      // new_w unchanged
      new_h -= d_y;

      if ( aspect > 0 ) {
          new_w = new_h * aspect;
          new_x += 0.5 * aspect * d_y;
      }
      new_w = std::max ( new_w, 20.0f );
      new_h = std::max ( new_h, 20.0f );

      if (view) view -> setDrawRect ( new_x, new_y, new_w, new_h );
      if (gv) gv -> setDrawRect ( new_x, new_y, new_w, new_h );

      rect->setEnabled ( true );
      break;
        
    case lower_right:

      // new_x unchanged
      // new_y unchanged
      new_w -= d_x;
      new_h -= d_y;      

      if ( aspect > 0 ) {
        new_h -= d_x;
        new_w = aspect * new_h;
        new_y += d_x;
      }
      new_w = std::max ( new_w, 20.0f );
      new_h = std::max ( new_h, 20.0f );

      if (view) view -> setDrawRect ( new_x, new_y, new_w, new_h );
      if (gv) gv -> setDrawRect ( new_x, new_y, new_w, new_h );

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

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

}



void
FigureEditor::
contentsMouseReleaseEvent ( QMouseEvent * e )
{
  if (!m_isMouseDown) return;

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

  // Mouse has not moved, process as a click.
  if ( p==m_mouse_down ) {
    setSelectedItem(m_preSelected);
    m_isMouseDown = false;
  }

}


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

  int margin_x = 0;
  int margin_y = 0;
  int max_width = 0;

  if ( m_ignore_margin == false ) {
    margin_x = ( m_apage_w - m_upage_w ) / 2;
    margin_y = ( m_apage_h - m_upage_h ) / 2;
    max_width = m_apage_w - margin_x;
  }
  else {
    max_width = m_canvas -> width ();
  }

  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 ) {
    if ( m_ignore_margin == false ) {
      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 () < max_width ) {
      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 ();
  QRect area = item -> boundingRect ();
  m_canvas -> setChanged ( area );
  m_canvas -> update();
}

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
  unsigned int count = items.count ();
  if ( count > 1 ) {

    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 ()
{
 #if QT_VERSION < 0x040000
 bool yes = s_printer -> setup ( this );
//  if ( yes == false ) return;
#else
 QPrintDialog dialog ( s_printer, this );
 bool yes = ( dialog.exec () == QDialog::Accepted );
#endif

 if ( yes ) {
   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 )
{
  setSelectedItems ( false ); // hide border
  QPainter painter;
  bool ok = painter.begin ( printer );
  assert ( ok );

  calcPrinterMetrics ( painter.device () );
  double scale = 1.0 / m_scale_factor;
  painter.scale ( scale, scale );
  int page_y = 0;
  int trans_y = static_cast < int > ( m_apage_h * m_scale_factor );

  while ( page_y < m_canvas->height() ) {
    const QRect clip ( 0, page_y, m_apage_w, m_apage_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, - trans_y );
      continue;
    }

    if ( page_y != 0 ) printer->newPage();
    page_y += m_apage_h;

    bool dbuf = false;

    m_canvas->drawArea ( clip, & painter, dbuf );
    painter.translate ( 0, - trans_y );
  }

  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 );
  setSelectedItems ( true ); // restore
}

QPixmap *
FigureEditor::
createPixmap ( const QRect & rect ) const
{
  QPixmap * pixmap = new QPixmap ( rect.width(), rect.height() );
  QPainter painter;

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

  return pixmap;
}

void
FigureEditor::
saveAreaAsPixmap ( const QRect & rect, const std::string & filename )
{
  QPixmap * pixmap = createPixmap ( rect );

  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() );

  delete pixmap;
}

QImage
FigureEditor::
createImage ( const QRect & rect ) const
{
  QPixmap * pixmap = createPixmap ( rect );
  QImage image = pixmap -> convertToImage ();

  return image;
}

void
FigureEditor::
copySelectedToClipboard ()
{
  QRect rect = getSelectedBounds ();
  QImage image = createImage ( rect );
#if QT_VERSION < 0x040000
  QImageDrag * image_drag = new QImageDrag ( image );
#else
  Q3ImageDrag * image_drag = new Q3ImageDrag ( image );
#endif
  QClipboard *  cb =  QApplication::clipboard ();
  cb -> setData ( image_drag );
}

void 
FigureEditor::
setZoomMode ( bool flag )
{
  m_zoom_mode = flag;
  if ( flag ) {
    QApplication::setOverrideCursor( QCursor ( Qt::CrossCursor ) );
    QWidget * view_port = viewport ();
    view_port -> setMouseTracking ( TRUE );
  }
  else {
    QApplication::restoreOverrideCursor();
    QWidget * view_port = viewport ();
    view_port -> setMouseTracking ( FALSE );
  }
}

void
FigureEditor::
leaveEvent ( QEvent * )
{
  QApplication::restoreOverrideCursor ();
}

void
FigureEditor::
enterEvent ( QEvent * )
{
  if ( m_zoom_mode == true ) {
    QApplication::setOverrideCursor ( QCursor ( Qt::CrossCursor ) );
  }
}

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

const QString &
FigureEditor::
getAppKey () const
{
  return s_app_key;
}

const QString &
FigureEditor::
getRegistry () const
{
  return s_registry;
}

#if QT_VERSION < 0x040000
QCanvasItem * 
#else
Q3CanvasItem *
#endif
FigureEditor::getRightItem ()
{
  return m_rightItem;
}

void
FigureEditor::
mouseMoveMultiItem( QMouseEvent * e )
{
  if (getZoomMode()) return;

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

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

  while ( it != m_selected_list.end() )
    {
      movePlotterWithText ( *it, p.x()-m_moving_start.x(), p.y()-m_moving_start.y());
      it++;
    }
  m_moving_start = p;  

  m_canvas->update();
}

void
FigureEditor::
#if QT_VERSION < 0X040000
movePlotterWithText( QCanvasItem * item, float dx, float dy )
#else 
movePlotterWithText ( Q3CanvasItem * item, float dx, float dy )
#endif  
{
    
#if QT_VERSION < 0x040000
  QCanvasItemList item_list = m_canvas->allItems();
  QCanvasItemList::Iterator it = item_list.begin();
#else
  Q3CanvasItemList item_list = m_canvas->allItems();
  Q3CanvasItemList::Iterator it = item_list.begin();
#endif
  
  QtView * xyview = dynamic_cast < QtView * > ( item );
  PlotterBase * xyplotter = xyview->getPlotter();
  
  /* Move the selected plotter */
  item->moveBy(dx,dy);
  
  /* Move all child text plotters */
  for ( ; it !=item_list.end(); ++it ) {
    const QtView * view = dynamic_cast < const QtView * > ( *it);
    if (view!=0){
      PlotterBase * plotter = view->getPlotter();
      if ( (plotter->isTextPlotter()) && (plotter->getParentPlotter()==xyplotter) ){
        (*it)->moveBy(dx,dy);
      }      
    }
  }     
}