home *** CD-ROM | disk | FTP | other *** search
/ Power GUI Programming with VisualAge C++ / powergui.iso / trialva / ibmcppw / samples / visbuild / doodle / darea / darea.cpp next >
Encoding:
C/C++ Source or Header  |  1996-02-16  |  31.1 KB  |  873 lines
  1. /******************************************************************************
  2. * .FILE:        darea.cpp                                                     *
  3. *                                                                             *
  4. * .DESCRIPTION: Implementation for the class, DrawingArea                     *
  5. *                                                                             *
  6. * .CLASSES:     DrawingArea                                                   *
  7. *                                                                             *
  8. * .COPYRIGHT:                                                                 *
  9. *    Licensed Material - Program-Property of IBM                              *
  10. *    (C) Copyright IBM Corp. 1992, 1996 - All Rights Reserved                 *
  11. *                                                                             *
  12. * .DISCLAIMER:                                                                *
  13. *   The following [enclosed] code is sample code created by IBM               *
  14. *   Corporation.  This sample code is not part of any standard IBM product    *
  15. *   and is provided to you solely for the purpose of assisting you in the     *
  16. *   development of your applications.  The code is provided 'AS IS',          *
  17. *   without warranty of any kind.  IBM shall not be liable for any damages    *
  18. *   arising out of your use of the sample code, even if they have been        *
  19. *   advised of the possibility of such damages.                               *
  20. *                                                                             *
  21. * .NOTE: WE RECOMMEND USING A FIXED SPACE FONT TO LOOK AT THE SOURCE          *
  22. *                                                                             *
  23. ******************************************************************************/
  24.  
  25. #ifndef _IBASE_                         //Make sure ibase.hpp is included
  26.   #include <ibase.hpp>                  //  since that is where IC_<environ>
  27. #endif                                  //  is defined.
  28. #include "darea.hpp"
  29. #include <igline.hpp>
  30. #include <igpyline.hpp>
  31. #include <igelipse.hpp>
  32. #include <igarc.hpp>
  33. #include <igpie.hpp>
  34. #include <igstring.hpp>
  35. #include <igbitmap.hpp>
  36. #include <icolor.hpp>
  37. #include <iglist.hpp>
  38. #include <math.h>
  39.  
  40. /*------------------------------------------------------------------------------
  41. | angleFromPoints                                                              |
  42. |                                                                              |
  43. | Given two points determine the angle between the horizontal line through     |
  44. | the first point and the line from the first point to the second point.       |
  45. ------------------------------------------------------------------------------*/
  46. double angleFromPoints( const IPoint& center, const IPoint& drop )
  47. {
  48.   IPoint temp;
  49.   double angle;
  50.  
  51.   temp  = drop - center;
  52.   angle = atan2((double)temp.y(), (double)temp.x());
  53.   angle *= 57.295779;
  54.  
  55.   if ( angle < 0.0 )
  56.     angle += 360.0;
  57.  
  58.   return angle;
  59. }
  60.  
  61. /*------------------------------------------------------------------------------
  62. | DrawingArea::DrawingArea                                                     |
  63. |                                                                              |
  64. |                                                                              |
  65. ------------------------------------------------------------------------------*/
  66. DrawingArea::DrawingArea( unsigned long id, IWindow* parent,
  67.                           IWindow* owner, const IRectangle& rect )
  68.   : IDrawingCanvas( id, parent, owner, rect ),
  69.     gc(handle()),
  70.     currentfont(),
  71.     currentBundle(),
  72.     currentBitmap(),
  73.     dState( notDrawing ),
  74.     currentObj( move ),
  75.     iGraphic(0),
  76.     moveGraphic(0),
  77.     moveRect(IRectangle()),
  78.     startingPt(), previousPt(), tempPt(),
  79.     pointCount(0),
  80.     flyOverHandler(0)
  81. {
  82.   currentBundle.setPenColor(IGraphicContext::defaultPenColor())
  83.                .setFillColor(IGraphicContext::defaultFillColor())
  84.                .setMixMode(IGraphicContext::defaultMixMode())
  85.                .setPenJoiningStyle(IGraphicBundle::miter)
  86.                .setDrawOperation( IGraphicBundle::fillAndFrame );
  87.  
  88.   gc.setMixMode( IGraphicBundle::xor ).setPenColor( IColor::white )
  89.     .setFillColor( IColor::white )
  90.     .setDrawOperation( IGraphicBundle::frame )
  91.     .setHitApertureSize( ISize(2,2) );
  92.   setGraphicContext( &gc );
  93.  
  94.   setGraphicList( new IGList() );
  95.  
  96.   // Load the pointers.
  97.  
  98. //  IResourceLibrary reslib;
  99.   IDynamicLinkLibrary reslib("CPPWV53R");
  100.   ptrLine      = reslib.loadPointer( POINTER_LINE );
  101.   ptrFreehand  = reslib.loadPointer( POINTER_FREEHAND );
  102.   ptrRectangle = reslib.loadPointer( POINTER_RECTANGLE );
  103.   ptrEllipse   = reslib.loadPointer( POINTER_ELLIPSE );
  104.   ptrPolyline  = reslib.loadPointer( POINTER_POLYLINE );
  105.   ptrPolygon   = reslib.loadPointer( POINTER_POLYGON );
  106.   ptrArc       = reslib.loadPointer( POINTER_ARC );
  107.   ptrPie       = reslib.loadPointer( POINTER_PIE );
  108.   ptrChord     = reslib.loadPointer( POINTER_CHORD );
  109.   ptrText      = reslib.loadPointer( POINTER_TEXT );
  110.   ptrBitmap    = reslib.loadPointer( POINTER_BITMAP );
  111.   ptrStyleCan  = reslib.loadPointer( POINTER_STYLECAN );
  112.   ptrEraser    = reslib.loadPointer( POINTER_ERASER );
  113.  
  114.   ((IMouseHandler*)this)->handleEventsFor(this);
  115. }
  116.  
  117. /*------------------------------------------------------------------------------
  118. | DrawingArea::DrawingArea                                                     |
  119. |                                                                              |
  120. |                                                                              |
  121. ------------------------------------------------------------------------------*/
  122. DrawingArea::~DrawingArea( )
  123. {
  124.   // Delete all the graphic objects in the drawing canvas.
  125.   IGList::Cursor graphicsCursor( *graphicList() );
  126.   for ( graphicsCursor.setToFirst();
  127.         graphicsCursor.isValid();
  128.         graphicsCursor.setToNext() )
  129.   {
  130.     IGraphic* graphic(&(graphicList()->graphicAt(graphicsCursor)));
  131.     delete graphic;
  132.   } /* endfor */
  133.   delete graphicList();
  134. }
  135.  
  136. /*------------------------------------------------------------------------------
  137. | DrawingArea::changeMousePointer                                              |
  138. |                                                                              |
  139. | Change the cursor to reflect the object being drawn.                         |
  140. ------------------------------------------------------------------------------*/
  141. Boolean DrawingArea::mousePointerChange( IMousePointerEvent& event )
  142. {
  143.   Boolean fReturn(true);
  144.  
  145. //  if (event.windowId() != 32776)
  146. //    return(false);
  147. //  if (infoArea)
  148. //  {
  149. //    infoArea->setText("Set the text!");
  150. //  }
  151.  
  152.   switch (drawObject())
  153.   {
  154.     case POINTER_MOVE:
  155.       return fReturn = false;
  156.     break;
  157.     case POINTER_LINE:
  158.       event.setMousePointer( ptrLine );
  159.     break;
  160.     case POINTER_FREEHAND:
  161.       event.setMousePointer( ptrFreehand );
  162.     break;
  163.     case POINTER_RECTANGLE:
  164.       event.setMousePointer( ptrRectangle );
  165.     break;
  166.     case POINTER_ELLIPSE:
  167.       event.setMousePointer( ptrEllipse );
  168.     break;
  169.     case POINTER_POLYLINE:
  170.       event.setMousePointer( ptrPolyline );
  171.     break;
  172.     case POINTER_POLYGON:
  173.       event.setMousePointer( ptrPolygon );
  174.     break;
  175.     case POINTER_ARC:
  176.       event.setMousePointer( ptrArc );
  177.     break;
  178.     case POINTER_PIE:
  179.       event.setMousePointer( ptrPie );
  180.     break;
  181.     case POINTER_CHORD:
  182.       event.setMousePointer( ptrChord );
  183.     break;
  184.     case POINTER_TEXT:
  185.       event.setMousePointer( ptrText );
  186.     break;
  187.     case POINTER_BITMAP:
  188.       event.setMousePointer( ptrBitmap );
  189.     break;
  190.     case POINTER_STYLECAN:
  191.       event.setMousePointer( ptrStyleCan );
  192.     break;
  193.     case POINTER_ERASER:
  194.       event.setMousePointer( ptrEraser );
  195.     break;
  196.     default:
  197.       fReturn = false;
  198.     break;
  199.   } // end switch
  200.  
  201.   return fReturn;
  202. }
  203.  
  204. /*------------------------------------------------------------------------------
  205. | DrawingArea::mouseClicked                                                    |
  206. |                                                                              |
  207. | Translate the mouse clicked events.                                          |
  208. ------------------------------------------------------------------------------*/
  209. Boolean DrawingArea::mouseClicked( IMouseClickEvent& event )
  210. {
  211.   Boolean bRc = false;
  212.   if ( event.mouseButton() == IMouseClickEvent::button1 &&
  213.        event.mouseAction() == IMouseClickEvent::down )
  214.   {
  215.     button1Down(event.mousePosition());
  216.     bRc = false;
  217.   }
  218.   else if ( event.mouseButton() == IMouseClickEvent::button1 &&
  219.             event.mouseAction() == IMouseClickEvent::up )
  220.   {
  221.     button1Up(event.mousePosition());
  222.     bRc = true;
  223.   }
  224.   else if ( event.mouseButton() == IMouseClickEvent::button1 &&
  225.             event.mouseAction() == IMouseClickEvent::doubleClick )
  226.   {
  227.     button1DoubleClick(event.mousePosition());
  228.     bRc = true;
  229.   }
  230.   else if ( event.mouseButton() == IMouseClickEvent::button2 &&
  231.             event.mouseAction() == IMouseClickEvent::down )
  232.   {
  233.     button2Down(event.mousePosition());
  234.   }
  235.   else if ( event.mouseButton() == IMouseClickEvent::button2 &&
  236.             event.mouseAction() == IMouseClickEvent::up )
  237.   {
  238.     button2Up(event.mousePosition());
  239.   }
  240.  
  241.   return bRc;
  242. }
  243.  
  244.  
  245. /*------------------------------------------------------------------------------
  246. | DrawingArea::button1Down                                                     |
  247. |                                                                              |
  248. | Handle button 1 down messages.  This event indicates a new graphic object is |
  249. | to be created of additional data points to add to an existing graphic object.|
  250. ------------------------------------------------------------------------------*/
  251. DrawingArea& DrawingArea::button1Down( const IPoint& point )
  252. {
  253.   switch (currentObj)
  254.   {
  255.     case move: // Button 1 drag
  256.       if (drawState() == notDrawing)
  257.       {
  258.         moveGraphic = graphicList()->topGraphicUnderPoint( point, gc );
  259.         if ( moveGraphic )
  260.         {
  261.           moveRect.setEnclosingRect(moveGraphic->boundingRect( gc ));
  262.           previousPt = point;
  263.           startingPt = point;
  264.           capturePointer();
  265.         }
  266.       }
  267.     break;
  268.     case eraser:
  269.       {
  270.         // Delete the object under the pointer
  271.         moveGraphic = graphicList()->topGraphicUnderPoint( point, gc );
  272.         if ( moveGraphic )
  273.         {
  274.           moveRect.setEnclosingRect(moveGraphic->boundingRect( gc ));
  275.           IGList::Cursor cursor( *graphicList(), gc, point );
  276.           for (cursor.setToFirst(); cursor.isValid(); cursor.setToNext())
  277.           {
  278.              IGraphic* graphic(&(graphicList()->graphicAt(cursor)));
  279.              if (graphic == moveGraphic)
  280.              {
  281.                graphicList()->removeAt(cursor);
  282.                delete graphic;
  283.                this->refresh( moveRect.boundingRect(gc).expandBy(2) );
  284.                moveRect.resetTransformMatrix();
  285.                moveGraphic = 0;
  286.                break;
  287.              }
  288.           }
  289.         }
  290.       }
  291.     break;
  292.     case stylecan:
  293.     {
  294.       // Change all objects to the current pen and fill color.
  295.       IRectangle tempRect;
  296.       moveGraphic = graphicList()->topGraphicUnderPoint( point, gc );
  297.       if( moveGraphic )
  298.       {
  299.         tempRect = moveGraphic->boundingRect( gc );
  300.         moveGraphic->setGraphicBundle( currentBundle );
  301.         moveGraphic->drawOn( gc );
  302.         tempRect |= moveGraphic->boundingRect( gc );
  303.         this->refresh( tempRect.expandBy(2) );
  304.         moveGraphic = 0;
  305.       }
  306.     }
  307.     break;
  308.     case line:
  309.       startingPt = point;
  310.       previousPt = point;
  311.       iGraphic = new IGLine( startingPt, previousPt );
  312.       setDrawState();
  313.     break;
  314.     case freehand:
  315.       iGraphic = new IGPolygon(IPointArray());
  316.       ((IGPolygon*)iGraphic)->addPoint( point );
  317.       setDrawState();
  318.     break;
  319.     case rectangle:
  320.       startingPt = point;
  321.       previousPt = point;
  322.       iGraphic = new IGRectangle(IRectangle(startingPt, previousPt));
  323.       setDrawState();
  324.     break;
  325.     case ellipse:
  326.       startingPt = point;
  327.       previousPt = point;
  328.       iGraphic = new IGEllipse( startingPt, 0L );
  329.       setDrawState();
  330.     break;
  331.     case polyline:
  332.     case polygon:
  333.       if (drawState() == notDrawing)
  334.       {
  335.         startingPt = point;
  336.         previousPt = point;
  337.         if (currentObj == polyline)
  338.           iGraphic = new IGPolyline(IPointArray());
  339.         else
  340.           iGraphic = new IGPolygon(IPointArray());
  341.  
  342.         ((IGPolyline*)iGraphic)->addPoint( startingPt );
  343.         ((IGPolyline*)iGraphic)->addPoint( previousPt );
  344.         setDrawState();
  345.       }
  346.       else
  347.       {
  348.         ((IGPolyline*)iGraphic)->IGPolyline::drawOn( gc );
  349.         ((IGPolyline*)iGraphic)->addPoint( point );
  350.         ((IGPolyline*)iGraphic)->IGPolyline::drawOn( gc );
  351.       }
  352.     break;
  353.     case arc:
  354.       pointCount++;
  355.       if (drawState() == notDrawing)
  356.       {
  357.         iGraphic = new IG3PointArc( point, IPoint(0,0), IPoint(0,0) );
  358.         startingPt = point;
  359.         previousPt = point;
  360.       }
  361.       else if ( pointCount == 2 )
  362.       {
  363.         previousPt = point;
  364.         IGLine tempLine( ((IG3PointArc*)iGraphic)->startingPoint(), point );
  365.         tempLine.drawOn( gc );
  366.       }
  367.       else if ( pointCount == 3 )
  368.       {
  369.         IGLine tempLine( ((IG3PointArc*)iGraphic)->startingPoint(), previousPt );
  370.         tempLine.drawOn( gc );
  371.         previousPt = point;
  372.         ((IG3PointArc*)iGraphic)->setEndingPoint( point );
  373.         iGraphic->drawOn( gc );
  374.       }
  375.       setDrawState();
  376.     break;
  377.     case pie:
  378.     case chord:
  379.       pointCount++;
  380.       if (drawState() == notDrawing)
  381.       {
  382.         if (currentObj == pie)
  383.           iGraphic = new IGPie( IRectangle(), 0, 0);
  384.         else
  385.           iGraphic = new IGChord( IRectangle(), 0, 0);
  386.  
  387.         ((IGPie*)iGraphic)->setEnclosingRect(
  388.                              ((IGPie*)iGraphic)->enclosingRect().centerAt( point ));
  389.         startingPt = point;
  390.         previousPt = point;
  391.       }
  392.       else if ( pointCount == 2 )
  393.       {
  394.         previousPt = point;
  395.         IGLine tempLine( ((IGPie*)iGraphic)->enclosingRect().center(), point );
  396.         tempLine.drawOn( gc );
  397.       }
  398.       else if ( pointCount == 3 )
  399.       {
  400.         IGLine tempLine( ((IGPie*)iGraphic)->enclosingRect().center(), previousPt );
  401.         tempLine.drawOn( gc );
  402.         previousPt = point;
  403.         double sweep(angleFromPoints( ((IGPie*)iGraphic)->enclosingRect().center(), point ));
  404.         if ( sweep < ((IGPie*)iGraphic)->startAngle() )
  405.           ((IGPie*)iGraphic)->setSweepAngle( 360.0 -
  406.                                 ( ((IGPie*)iGraphic)->startAngle() - sweep ));
  407.         else
  408.           ((IGPie*)iGraphic)->setSweepAngle( sweep -
  409.                                             ((IGPie*)iGraphic)->startAngle());
  410.         iGraphic->drawOn( gc );
  411.       }
  412.       setDrawState();
  413.     break;
  414.     case text:
  415.       setDrawState();
  416.     break;
  417.     case bitmap:
  418.       setDrawState();
  419.     break;
  420.   } /* endswitch */
  421.   return *this;
  422. }
  423.  
  424. /*------------------------------------------------------------------------------
  425. | DrawingArea::button1Up                                                       |
  426. |                                                                              |
  427. | Handle button 1 up events.  This indicates a data points final location.     |
  428. ------------------------------------------------------------------------------*/
  429. DrawingArea& DrawingArea::button1Up( const IPoint& point )
  430. {
  431.   if ( drawState() == drawing )
  432.   {
  433.     switch (currentObj)
  434.     {
  435.       case move:
  436.       break;
  437.       case eraser:
  438.       break;
  439.       case stylecan:
  440.       break;
  441.       case line:
  442.         ((IGLine*)iGraphic)->setEndingPoint( point );
  443.         iGraphic->setGraphicBundle( currentBundle );
  444.         iGraphic->drawOn( gc );
  445.         setDrawState( notDrawing );
  446.         graphicList()->addAsLast( *iGraphic );
  447.       break;
  448.       case freehand:
  449.         ((IGPolygon*)iGraphic)->addPoint( point );
  450.         iGraphic->setGraphicBundle( currentBundle );
  451.         iGraphic->drawOn( gc );
  452.         setDrawState( notDrawing );
  453.         graphicList()->addAsLast( *iGraphic );
  454.       break;
  455.       case rectangle:
  456.       {
  457.         IRectangle rc(((IGRectangle*)iGraphic)->enclosingRect());
  458.         rc.sizeTo( rc.size() + point - previousPt );
  459.         ((IGRectangle*)iGraphic)->setEnclosingRect( rc );
  460.         iGraphic->setGraphicBundle( currentBundle );
  461.         iGraphic->drawOn( gc );
  462.         setDrawState( notDrawing );
  463.         graphicList()->addAsLast( *iGraphic );
  464.       }
  465.       break;
  466.       case ellipse:
  467.       {
  468.         IRectangle rc(((IGEllipse*)iGraphic)->enclosingRect());
  469.         rc.sizeTo( rc.size() + point - previousPt );
  470.         ((IGEllipse*)iGraphic)->setEnclosingRect( rc );
  471.  
  472.         iGraphic->setGraphicBundle( currentBundle );
  473.         iGraphic->drawOn( gc );
  474.         setDrawState( notDrawing );
  475.         graphicList()->addAsLast( *iGraphic );
  476.       }
  477.       break;
  478.       case polyline:
  479.       case polygon:
  480.         previousPt = point;
  481.         ((IGPolyline*)iGraphic)->setPoint(
  482.                          ((IGPolyline*)iGraphic)->numberOfPoints()-1, point );
  483.         setDrawState( waitingForInput );
  484.       break;
  485.       case arc:
  486.       if ( pointCount == 2 )
  487.       {
  488.         ((IG3PointArc*)iGraphic)->setIntermediatePoint( point );
  489.         gc.setMixMode( IGraphicBundle::xor ).setPenColor( IColor::white );
  490.         IGLine tempLine( ((IG3PointArc*)iGraphic)->startingPoint(), previousPt );
  491.         tempLine.drawOn( gc );
  492.         tempLine.setEndingPoint( point );
  493.         tempLine.drawOn( gc );
  494.         setDrawState( waitingForInput );
  495.       }
  496.       else if ( pointCount == 3 )
  497.       {
  498.         gc.setMixMode( IGraphicBundle::xor ).setPenColor( IColor::white );
  499.         iGraphic->drawOn( gc );
  500.         ((IG3PointArc*)iGraphic)->setEndingPoint( point );
  501.         iGraphic->setGraphicBundle( currentBundle );
  502.         iGraphic->drawOn( gc );
  503.         setDrawState( notDrawing );
  504.         graphicList()->addAsLast( *iGraphic );
  505.         pointCount = 0;
  506.       }
  507.       break;
  508.       case pie:
  509.       case chord:
  510.       if ( pointCount == 2 )
  511.       {
  512.         gc.setMixMode( IGraphicBundle::xor ).setPenColor( IColor::white );
  513.         setDrawState( waitingForInput );
  514.         IPoint centerPt(((IGPie*)iGraphic)->enclosingRect().center());
  515.  
  516.         ((IGPie*)iGraphic)->setStartAngle( angleFromPoints( centerPt, point ));
  517.  
  518.         unsigned a(abs(centerPt.x()) - abs(point.x()));
  519.         unsigned b(abs(centerPt.y()) - abs(point.y()));
  520.  
  521.         unsigned long radius((unsigned long)sqrt(a*a + b*b));
  522.  
  523.         ((IGPie*)iGraphic)->setEnclosingRect(
  524.            ((IGPie*)iGraphic)->enclosingRect().expandBy(radius));
  525.       }
  526.       else if ( pointCount == 3 )
  527.       {
  528.         gc.setMixMode( IGraphicBundle::xor ).setPenColor( IColor::white );
  529.         iGraphic->drawOn( gc );
  530.  
  531.         double sweep(angleFromPoints(
  532.                               ((IGPie*)iGraphic)->enclosingRect().center(), point ));
  533.  
  534.         if ( sweep < ((IGPie*)iGraphic)->startAngle() )
  535.           ((IGPie*)iGraphic)->setSweepAngle( 360.0 -
  536.                                 ( ((IGPie*)iGraphic)->startAngle() - sweep ));
  537.         else
  538.           ((IGPie*)iGraphic)->setSweepAngle( sweep -
  539.                                             ((IGPie*)iGraphic)->startAngle());
  540.  
  541.         iGraphic->setGraphicBundle( currentBundle );
  542.         iGraphic->drawOn( gc );
  543.         setDrawState( notDrawing );
  544.         graphicList()->addAsLast( *iGraphic );
  545.         pointCount = 0;
  546.       }
  547.       break;
  548.       case text:
  549.       {
  550.         IString input;
  551.  
  552.         IDynamicLinkLibrary reslib("CPPWV53R");
  553.  
  554.         if (point.x() % 2)
  555.           input = reslib.loadString( STRING_SAMPLE1 );
  556.         else if ((point.y() % 5)==1)
  557.           input = reslib.loadString( STRING_SAMPLE3 );
  558.         else if ((point.y() % 5)==3)
  559.           input = reslib.loadString( STRING_SAMPLE4 );
  560.         else
  561.           input = reslib.loadString( STRING_SAMPLE2 );
  562.  
  563.         IGString* text = new IGString( input.x2c(), point, currentFont());
  564. //      IGString* text = new IGString( "Doodle", point, currentFont());
  565.         text->rotateBy( 10.0, point );
  566.         text->setGraphicBundle( currentBundle );
  567.         text->drawOn( gc );
  568.         setDrawState( notDrawing );
  569.         graphicList()->addAsLast( *text );
  570.       }
  571.       break;
  572.       case bitmap:
  573.       {
  574.         IGBitmap *bmp;
  575. //      if (bitmapFileName().length() > 0)
  576. //      {
  577. //        bmp = new IGBitmap(bitmapFileName());
  578. //      }
  579.  
  580.         // Select a bitmap to load
  581.         IDynamicLinkLibrary reslib("CPPWV53R");
  582.  
  583.         if (point.x() % 2)
  584.           bmp = new IGBitmap(reslib.loadBitmap( BITMAP_SAMPLE1 ));
  585.         else if ((point.y() % 5)==1)
  586.           bmp = new IGBitmap(reslib.loadBitmap( BITMAP_SAMPLE3 ));
  587.         else if ((point.y() % 5)==3)
  588.           bmp = new IGBitmap(reslib.loadBitmap( BITMAP_SAMPLE4 ));
  589.         else
  590.           bmp = new IGBitmap(reslib.loadBitmap( BITMAP_SAMPLE2 ));
  591.  
  592.         bmp->moveTo( point );
  593.         bmp->drawOn( gc );
  594.         setDrawState( notDrawing );
  595.         graphicList()->addAsLast( *bmp );
  596.       }
  597.       break;
  598.     } /* endswitch */
  599.   } /* endif */
  600.   else  // not drawing
  601.   {
  602.     switch (currentObj)
  603.     {
  604.       case move:
  605.         if (moveGraphic && capturePointer)
  606.         {
  607.           moveRect.translateBy( point - previousPt );
  608.           moveRect.drawOn( gc );
  609.           moveRect.resetTransformMatrix();
  610.           this->refresh( moveRect.boundingRect(gc).expandBy(2) );
  611.           moveGraphic->translateBy( point - startingPt );
  612.           moveGraphic->drawOn( gc );
  613.           moveGraphic = 0;
  614.           capturePointer(false);
  615.         }
  616.       break;
  617.     }
  618.   }
  619.   return *this;
  620. }
  621.  
  622. /*------------------------------------------------------------------------------
  623. | DrawingArea::button1DoubleClick                                              |
  624. |                                                                              |
  625. | Handle button 1 up double click events.  In the case of polyline and polygon |
  626. | a double click indicates the user has finished adding data points to the     |
  627. | object.                                                                      |
  628. ------------------------------------------------------------------------------*/
  629. DrawingArea& DrawingArea::button1DoubleClick( const IPoint& point )
  630. {
  631.   if (drawState() == waitingForInput )
  632.   {
  633.     switch (currentObj)
  634.     {
  635.       case polyline:
  636.       {
  637.         iGraphic->drawOn( gc );
  638.         iGraphic->setGraphicBundle( currentBundle );
  639.         iGraphic->drawOn( gc );
  640.         setDrawState( notDrawing );
  641.         graphicList()->addAsLast( *iGraphic );
  642.       }
  643.       break;
  644.       case polygon:
  645.       {
  646.         ((IGPolyline*)iGraphic)->IGPolyline::drawOn( gc );
  647.         iGraphic->setGraphicBundle( currentBundle );
  648.         iGraphic->drawOn( gc );
  649.         setDrawState( notDrawing );
  650.         graphicList()->addAsLast( *iGraphic );
  651.       }
  652.       break;
  653.     }
  654.   }
  655.   return *this;
  656. }
  657.  
  658. /*------------------------------------------------------------------------------
  659. | DrawingArea::button2Down                                                     |
  660. |                                                                              |
  661. | Determine the object under the mouse and start moving.                       |
  662. ------------------------------------------------------------------------------*/
  663. DrawingArea& DrawingArea::button2Down( const IPoint& point )
  664. {
  665.   if (drawState() == notDrawing)
  666.   {
  667.     moveGraphic = graphicList()->topGraphicUnderPoint( point, gc );
  668.     if ( moveGraphic )
  669.     {
  670.       moveRect.setEnclosingRect(moveGraphic->boundingRect( gc ));
  671.       previousPt = point;
  672.       startingPt = point;
  673.       capturePointer();
  674.     }
  675.   }
  676.   return *this;
  677. }
  678.  
  679. /*------------------------------------------------------------------------------
  680. | DrawingArea::button2Up                                                       |
  681. |                                                                              |
  682. ------------------------------------------------------------------------------*/
  683. DrawingArea& DrawingArea::button2Up( const IPoint& point )
  684. {
  685.   if (moveGraphic)
  686.   {
  687.     moveRect.translateBy( point - previousPt );
  688.     moveRect.drawOn( gc );
  689.     moveRect.resetTransformMatrix();
  690.     this->refresh( moveRect.boundingRect(gc).expandBy(2) );
  691.     moveGraphic->translateBy( point - startingPt );
  692.     moveGraphic->drawOn( gc );
  693.     moveGraphic = 0;
  694.     capturePointer(false);
  695.   }
  696.   return *this;
  697. }
  698.  
  699. /*------------------------------------------------------------------------------
  700. | DrawingArea::mouseMoved                                                      |
  701. |                                                                              |
  702. | Handle button 1 down mouse move events.  This allows data points to be       |
  703. | moved while the object is drawn with a rubber band effect.                   |
  704. ------------------------------------------------------------------------------*/
  705. Boolean DrawingArea::mouseMoved( IMouseEvent& event )
  706. {
  707.   IPoint point(event.mousePosition());
  708.   if ( hasPointerCaptured() )
  709.   {
  710.     IRectangle windowRect(this->rect());
  711.     windowRect.moveTo(IPoint(0,0));
  712.     if (!windowRect.contains(point))
  713.     {
  714.       if ((short)point.x() < (short)windowRect.left())
  715.         point.setX(windowRect.left());
  716.       else if ((short)point.x() > (short)windowRect.right())
  717.         point.setX(windowRect.right());
  718.       else if ((short)point.y() < (short)windowRect.bottom())
  719.         point.setY(windowRect.bottom());
  720.       else if ((short)point.y() > (short)windowRect.top())
  721.         point.setY(windowRect.top());
  722.  
  723.       IPoint mapPt( IWindow::mapPoint( point,
  724.                                        this->handle(),
  725.                                        IWindow::desktopWindow()->handle()));
  726.  
  727.       IWindow::movePointerTo( mapPt );
  728.     }
  729.   }
  730.  
  731.   // If we're not moving an object
  732.   if (!moveGraphic)
  733.   {
  734.     if (( drawState() == drawing ) || ( drawState() == waitingForInput ))
  735.     {
  736.       switch (currentObj)
  737.       {
  738.         case move:
  739.         break;
  740.         case eraser:
  741.         break;
  742.         case stylecan:
  743.         break;
  744.         case line:
  745.           ((IGLine*)iGraphic)->drawOn( gc );
  746.           ((IGLine*)iGraphic)->setEndingPoint( point );
  747.           ((IGLine*)iGraphic)->drawOn( gc );
  748.         break;
  749.         case freehand:
  750.           ((IGPolygon*)iGraphic)->addPoint( point );
  751.           ((IGPolyline*)iGraphic)->IGPolyline::drawOn( gc );
  752.         break;
  753.         case rectangle:
  754.         {
  755.           IRectangle rc(((IGRectangle*)iGraphic)->enclosingRect());
  756.           iGraphic->drawOn( gc );
  757.           rc.sizeTo( rc.size() + point - previousPt );
  758.           ((IGRectangle*)iGraphic)->setEnclosingRect( rc );
  759.           iGraphic->drawOn( gc );
  760.           previousPt = point;
  761.         }
  762.         break;
  763.         case ellipse:
  764.         {
  765.           iGraphic->drawOn( gc );
  766.           IRectangle rc(((IGEllipse*)iGraphic)->enclosingRect());
  767.           rc.sizeTo( rc.size() + point - previousPt );
  768.           ((IGEllipse*)iGraphic)->setEnclosingRect( rc );
  769.           iGraphic->drawOn( gc );
  770.           previousPt = point;
  771.         }
  772.         break;
  773.         case polyline:
  774.         case polygon:
  775.           ((IGPolyline*)iGraphic)->IGPolyline::drawOn( gc );
  776.           ((IGPolyline*)iGraphic)->setPoint(
  777.                            ((IGPolyline*)iGraphic)->numberOfPoints()-1, point );
  778.           ((IGPolyline*)iGraphic)->IGPolyline::drawOn( gc );
  779.         break;
  780.         case arc:
  781.           if (drawState() != waitingForInput)
  782.           {
  783.             if ( pointCount == 2 )
  784.             {
  785.               IGLine tempLine( ((IG3PointArc*)iGraphic)->startingPoint(), previousPt );
  786.               tempLine.drawOn( gc );
  787.               tempLine.setEndingPoint( point );
  788.               tempLine.drawOn( gc );
  789.               previousPt = point;
  790.             } else if ( pointCount == 3 ) {
  791.               iGraphic->drawOn( gc );
  792.               ((IG3PointArc*)iGraphic)->setEndingPoint( point );
  793.               iGraphic->drawOn( gc );
  794.             }
  795.           } /* endif */
  796.         break;
  797.         case pie:
  798.         case chord:
  799.           if (drawState() != waitingForInput)
  800.           {
  801.             if ( pointCount == 2 )
  802.             {
  803.               IGLine tempLine( ((IGPie*)iGraphic)->enclosingRect().center(), previousPt );
  804.               tempLine.drawOn( gc );
  805.               tempLine.setEndingPoint( point );
  806.               tempLine.drawOn( gc );
  807.               previousPt = point;
  808.             } else if ( pointCount == 3 ) {
  809.               iGraphic->drawOn( gc );
  810.               double sweep(angleFromPoints( ((IGPie*)iGraphic)->enclosingRect().center(), point ));
  811.               if ( sweep < ((IGPie*)iGraphic)->startAngle() )
  812.                 ((IGPie*)iGraphic)->setSweepAngle( 360.0 -
  813.                                     ( ((IGPie*)iGraphic)->startAngle() - sweep ));
  814.               else
  815.                 ((IGPie*)iGraphic)->setSweepAngle( sweep -
  816.                                                 ((IGPie*)iGraphic)->startAngle());
  817.               iGraphic->drawOn( gc );
  818.             }
  819.           } /* endif */
  820.         break;
  821.       } /* endswitch */
  822.     }
  823.   }
  824.   else  // We are moving a graphic
  825.   {
  826.     moveRect.drawOn( gc );
  827.     moveRect.translateBy( point - previousPt );
  828.     moveRect.drawOn( gc );
  829.     previousPt = point;
  830.   }
  831.   return false;
  832. }
  833.  
  834. /*------------------------------------------------------------------------------
  835. | DrawingArea::setDrawState                                                    |
  836. |                                                                              |
  837. |                                                                              |
  838. ------------------------------------------------------------------------------*/
  839. DrawingArea& DrawingArea::setDrawState( const DrawState newState )
  840. {
  841.   dState = newState;
  842.   if (dState == drawing)
  843.   {
  844.     if (!hasPointerCaptured())
  845.       capturePointer();
  846.   }
  847.   else if (dState == notDrawing)
  848.     capturePointer(false);
  849.   return *this;
  850. }
  851.  
  852. /*------------------------------------------------------------------------------
  853. | DrawingArea::setFont                                                         |
  854. |                                                                              |
  855. |                                                                              |
  856. ------------------------------------------------------------------------------*/
  857. DrawingArea& DrawingArea::setCurrentFont( const IFont& font )
  858. {
  859.   currentfont = font;
  860.   return *this;
  861. }
  862.  
  863. /*------------------------------------------------------------------------------
  864. | DrawingArea::font                                                            |
  865. |                                                                              |
  866. |                                                                              |
  867. ------------------------------------------------------------------------------*/
  868. IFont DrawingArea::currentFont( ) const
  869. {
  870.   return currentfont;
  871. }
  872.  
  873.