Horus Doc || Java GUI Reference || Doxygen's quick Index  

ScribbleCanvas Class Reference

Inheritance diagram for ScribbleCanvas::

ActiveCanvas LayeredCanvas IcsCanvas List of all members.

Public Methods

 ScribbleCanvas (int checkMode)
 ScribbleCanvas (Dimension d, boolean fixedSize, int checkMode)
void setCanvasEditUser (CanvasEditUser user)
void paintComponent (Graphics g)
void clear ()
 Clear the canvas, i.e. More...

void zoom (double zoomVal)
 Zoom to the given value. More...

int getMode ()
 Overrides ActiveCanvas interface. More...

int getSubMode ()
 Overrides ActiveCanvas interface. More...

void setMode (int mode, int subMode)
 Overrides ActiveCanvas interface. More...

void actionPerformed (ActionEvent event)
void handleJavaFuncDialogOK (Object target, CallableMethod method, Object[] argVals)
void handleMousePress (MouseEvent e)
 Interface for MouseListener events, called by LayeredCanvasPane. More...

void handleMouseEnter (MouseEvent e)
void handleMouseExit (MouseEvent e)
void handleMouseMove (MouseEvent e)
 Interface for MouseMotionListener events, called by LayeredCanvasPane. More...

void handleMouseDrag (MouseEvent e)

Protected Methods

void drawImages (Graphics g)
void drawObjects (Graphics g)
void zoomObjects (double zoomValue)
ScribbleFigure createDrawFigure (int x, int y)
void handleFigureDraw (MouseEvent e)
void handleFigureDelete (MouseEvent e)
void handleFigureDelPoint (MouseEvent e)
void handleFigureMoveCopy (MouseEvent e)
void handleFigureModify (MouseEvent e)
boolean isDrawing ()
boolean inDrawMode (int mode)
boolean inFigureMode (int mode)
boolean inComplexSelectionMode (int mode)
void selectObject ()
void unselectObject ()
void popUpObjectMenu ()

Protected Attributes

DrawField df = null
Selector selector = null
ScribbleFigure oldFigure = null
boolean mouseInside = false
boolean popUpHandling = false
int curMode = SELECTION
int selPoint = -1
int selLayer = -1
int selIndex = -1
int oldIndex = -1
int oldObjID = -1
int selX = -1
int selY = -1
CallableMethod[] methods = null

Static Protected Attributes

final int IMAGE_LAYER = 0
final int FIGURE_LAYER = 1
final int NR_OF_LAYERS = 2
final String CANVAS_IMAGE_CLASS = "HxJava.CanvasObject.CanvasImage"
final String CANVAS_FIGURE_CLASS = "HxJava.CanvasObject.ScribbleFigure"

Constructor & Destructor Documentation

ScribbleCanvas::ScribbleCanvas (  int    checkMode )  [inline]
  

00034 {
00035     this(new Dimension(MIN_SIZE, MIN_SIZE), false, checkMode);
00036 }

ScribbleCanvas::ScribbleCanvas (  Dimension    d,
boolean    fixedSize,
int    checkMode
)  [inline]
  

00040 {
00041     super(d, fixedSize, NR_OF_LAYERS, checkMode);
00042 
00043     declareClassAt(CANVAS_IMAGE_CLASS, IMAGE_LAYER);
00044     declareClassAt(CANVAS_FIGURE_CLASS, FIGURE_LAYER);
00045 }

Member Function Documentation

void ScribbleCanvas::setCanvasEditUser (  CanvasEditUser    user )  [inline]
  

00052 {
00053     _editUser = user;
00054 }

void ScribbleCanvas::paintComponent (  Graphics    g )  [inline]
  

00058 {
00059 if (DEBUG_LAYOUT) {
00060 OutputStreamArea.println("ScribbleCanvas::paint (" + getID() + ") " + g.getClipBounds());
00061 dump();
00062 }
00063     drawImages(g);
00064     drawObjects(g);
00065     if (isDrawing()) {
00066         df.paintComponent(g);
00067     }
00068     if (selector != null) {
00069         selector.drawSquares(g);
00070     }
00071 }

void ScribbleCanvas::clear (    )  [inline]
 

Clear the canvas, i.e.

remove all objects from the canvas and draw the background color on the entire canvas.

Reimplemented from LayeredCanvas. 

00075 {
00076     selector = null;
00077     super.clear();
00078 }

void ScribbleCanvas::zoom (  double    zoomVal )  [inline]
 

Zoom to the given value.

Will adjust the canvas size by setting the CCS extent.

Reimplemented from IcsCanvas. 

00082 {
00083     if (zoomVal == getZoomFactor())
00084         return;
00085 
00086     super.zoom(zoomVal);
00087     zoomObjects(zoomVal);
00088 //        repaint(0);
00089 }

int ScribbleCanvas::getMode (    )  [inline]
 

Overrides ActiveCanvas interface.

Reimplemented from ActiveCanvas. 

00095 {
00096     switch (curMode) {
00097     case SELECTION:         return ViewerMode.SELECT;
00098     case DRAW_POINT:        return ViewerMode.DRAW;
00099     case DRAW_LINE:         return ViewerMode.DRAW;
00100     case DRAW_SQUARE:       return ViewerMode.DRAW;
00101     case DRAW_RECTANGLE:    return ViewerMode.DRAW;
00102     case DRAW_CIRCLE:       return ViewerMode.DRAW;
00103     case DRAW_OVAL:         return ViewerMode.DRAW;
00104     case DRAW_POLYLINE:     return ViewerMode.DRAW;
00105     case DRAW_POLYGON:      return ViewerMode.DRAW;
00106     case DRAW_FREE_OPEN:    return ViewerMode.DRAW;
00107     case DRAW_FREE_CLOSED:  return ViewerMode.DRAW;
00108     case DRAW_ARROW:        return ViewerMode.DRAW;
00109     case DRAW_STRING:       return ViewerMode.DRAW;
00110     case FIG_MOVE:          return ViewerMode.MOVE;
00111     case FIG_COPY:          return ViewerMode.COPY;
00112     case FIG_RESIZE:        return ViewerMode.RESIZE;
00113     case FIG_MOV_POINT:     return ViewerMode.RESHAPE;
00114     case FIG_DEL_POINT:     return ViewerMode.RESHAPE;
00115     case FIG_DELETE:        return ViewerMode.DELETE;
00116     }
00117     return -1;
00118 }

int ScribbleCanvas::getSubMode (    )  [inline]
 

Overrides ActiveCanvas interface.

Reimplemented from ActiveCanvas. 

00124 {
00125     switch (curMode) {
00126     case DRAW_POINT:        return ViewerMode.DRAW_POINT;
00127     case DRAW_LINE:         return ViewerMode.DRAW_LINE;
00128     case DRAW_SQUARE:       return ViewerMode.DRAW_SQUARE;
00129     case DRAW_RECTANGLE:    return ViewerMode.DRAW_RECTANGLE;
00130     case DRAW_CIRCLE:       return ViewerMode.DRAW_CIRCLE;
00131     case DRAW_OVAL:         return ViewerMode.DRAW_OVAL;
00132     case DRAW_POLYLINE:     return ViewerMode.DRAW_POLYLINE;
00133     case DRAW_POLYGON:      return ViewerMode.DRAW_POLYGON;
00134     case DRAW_FREE_OPEN:    return ViewerMode.DRAW_FREE_OPEN;
00135     case DRAW_FREE_CLOSED:  return ViewerMode.DRAW_FREE_CLOSED;
00136     case DRAW_ARROW:        return ViewerMode.DRAW_ARROW;
00137     case DRAW_STRING:       return ViewerMode.DRAW_STRING;
00138     case FIG_MOV_POINT:     return ViewerMode.RESHAPE_MOVE_P;
00139     case FIG_DEL_POINT:     return ViewerMode.RESHAPE_DEL_P;
00140     }
00141     return -1;
00142 }

void ScribbleCanvas::setMode (  int    mode,
int    subMode
)  [inline]
 

Overrides ActiveCanvas interface.

Reimplemented from ActiveCanvas. 

00148 {
00149     switch (mode) {
00150     case ViewerMode.SELECT:  { setCurMode(SELECTION); return; }
00151     case ViewerMode.DRAW:    {
00152         switch (subMode) {
00153         case ViewerMode.DRAW_POINT:       { setCurMode(DRAW_POINT); return; }
00154         case ViewerMode.DRAW_LINE:        { setCurMode(DRAW_LINE); return; }
00155         case ViewerMode.DRAW_SQUARE:      { setCurMode(DRAW_SQUARE); return; }
00156         case ViewerMode.DRAW_RECTANGLE:   { setCurMode(DRAW_RECTANGLE); return; }
00157         case ViewerMode.DRAW_CIRCLE:      { setCurMode(DRAW_CIRCLE); return; }
00158         case ViewerMode.DRAW_OVAL:        { setCurMode(DRAW_OVAL); return; }
00159         case ViewerMode.DRAW_POLYLINE:    { setCurMode(DRAW_POLYLINE); return; }
00160         case ViewerMode.DRAW_POLYGON:     { setCurMode(DRAW_POLYGON); return; }
00161         case ViewerMode.DRAW_FREE_OPEN:   { setCurMode(DRAW_FREE_OPEN); return; }
00162         case ViewerMode.DRAW_FREE_CLOSED: { setCurMode(DRAW_FREE_CLOSED); return; }
00163         case ViewerMode.DRAW_ARROW:       { setCurMode(DRAW_ARROW); return; }
00164         case ViewerMode.DRAW_STRING:      { setCurMode(DRAW_STRING); return; }
00165         }
00166         return; // do not know mode
00167                              }
00168     case ViewerMode.MOVE:    { setCurMode(FIG_MOVE); return; }
00169     case ViewerMode.COPY:    { setCurMode(FIG_COPY); return; }
00170     case ViewerMode.RESIZE:  { setCurMode(FIG_RESIZE); return; }
00171     case ViewerMode.RESHAPE: {
00172         switch (subMode) {
00173         case ViewerMode.RESHAPE_MOVE_P:   { setCurMode(FIG_MOV_POINT); return; }
00174         case ViewerMode.RESHAPE_DEL_P:    { setCurMode(FIG_DEL_POINT); return; }
00175         }
00176         return; // do not know mode
00177                              }
00178     case ViewerMode.DELETE:  { setCurMode(FIG_DELETE); return; }
00179     }
00180 }

void ScribbleCanvas::actionPerformed (  ActionEvent    event )  [inline]
  

00231 {
00232     String command = event.getActionCommand();
00233     MouseEvent me  = new MouseEvent(this, -1, -1, -1,
00234                                     selX, selY, -1, false);
00235 
00236     if (command.equals("Delete")) {
00237         curMode = FIG_DELETE;
00238         handleFigureDelete(me);
00239     } else {
00240         if (command.equals("Move")) {
00241             curMode = FIG_MOVE;
00242             handleFigureMoveCopy(me);
00243         } else if (command.equals("Copy")) {
00244             curMode = FIG_COPY;
00245             handleFigureMoveCopy(me);
00246         } else if (command.equals("Resize")) {
00247             curMode = FIG_RESIZE;
00248             Vector objvec = new Vector();
00249             objvec.addElement(getObject(selLayer, selIndex));
00250             selector = new Selector(this.getGraphics(),
00251                                     objvec, Selector.BOXES);
00252         } else if (command.equals("Delete Point") ||
00253                    command.equals("Move Point")) {
00254             Vector objvec = new Vector();
00255             objvec.addElement(getObject(selLayer, selIndex));
00256             selector = new Selector(this.getGraphics(),
00257                                     objvec, Selector.COMPLEX);
00258             if (command.equals("Delete Point")) {
00259                 curMode = FIG_DEL_POINT;
00260             } else if (command.equals("Move Point")) {
00261                 curMode = FIG_MOV_POINT;
00262             }
00263         } else if (command.equals("Cancel")) {
00264             popUpHandling = false;
00265         } else {
00266             if (methods == null) {
00267                 return;
00268             }
00269             for (int i=0; i<methods.length; i++) {
00270                 if (command.equals(methods[i].getMethodName())) {
00271                     Object target = getObject(selLayer, selIndex);
00272                     CallableMethod actMethod = methods[i];
00273                     if (actMethod.getNumArgs() > 0) {
00274                         new JavaFuncDialog(target, actMethod, this,
00275                                            "handleJavaFuncDialogOK",false);
00276                     } else {
00277                         handleJavaFuncDialogOK(target, actMethod, null);
00278                     }
00279                     break;
00280                 }
00281             }
00282         }
00283     }
00284 }

void ScribbleCanvas::handleJavaFuncDialogOK (  Object    target,
CallableMethod    method,
Object    argVals[]
)  [inline]
  

00289 {
00290     CanvasObject cf = getObject(selLayer, selIndex);
00291     if (cf != null) {
00292         method.invoke(target, argVals);
00293         cf.setZoomFactor(getZoomFactor());
00294 if (DEBUG_EVENTS)
00295 OutputStreamArea.println("VISUAL MODIFICATION PERFORMED");
00296         if (_editUser != null)
00297             _editUser.objectChangedVisually(this, cf,
00298                                 _repository.getObjectID(selLayer, selIndex),
00299                                 method.getMethodName());
00300         repaint();
00301     }
00302     popUpHandling = false;
00303     repaint();
00304 }

void ScribbleCanvas::handleMousePress (  MouseEvent    e )  [inline]
 

Interface for MouseListener events, called by LayeredCanvasPane.

Reimplemented from ActiveCanvas. 

00311 {
00312 if (DEBUG_EVENTS)
00313 OutputStreamArea.println("SC handleMousePress (" + getID() + "): " + e.getPoint());
00314     if (!mouseInside) {
00315         return;
00316 
00317     } else if (e.isMetaDown() && !isDrawing()) {    // Right mouse
00318 
00319         // Exit from current mode,...
00320 
00321         curMode = SELECTION;
00322         popUpHandling = false;
00323         unselectObject();
00324         selector = null;
00325         repaint();
00326 
00327         // ...see which object is selected,...
00328 
00329         super.handleMousePress(e);
00330         selectObject();
00331 
00332         // ..., and pop-up appropriate menu
00333 
00334         if (selIndex >= 0) {
00335             popUpObjectMenu();
00336         }
00337         return;
00338 
00339     } else if (curMode == FIG_DELETE) {
00340         handleFigureDelete(e);
00341         return;
00342     } else if (curMode == FIG_DEL_POINT) {
00343         handleFigureDelPoint(e);
00344         return;
00345     } else if (curMode == FIG_MOVE || curMode == FIG_COPY) {
00346         handleFigureMoveCopy(e);
00347         return;
00348     } else if (curMode == FIG_RESIZE || curMode == FIG_MOV_POINT) {
00349         handleFigureModify(e);
00350         return;
00351 
00352     } else if (inDrawMode(curMode)) {
00353         handleFigureDraw(e);
00354         return;
00355     }
00356 
00357     super.handleMousePress(e);
00358 }

void ScribbleCanvas::handleMouseEnter (  MouseEvent    e )  [inline]
 

Reimplemented from ActiveCanvas. 

00362 {
00363 if (DEBUG_EVENTS)
00364 OutputStreamArea.println("SC handleMouseEnter (" + getID() + "): " + e.getPoint());
00365     mouseInside = true;
00366 
00367     if (inDrawMode(curMode)) {
00368         return;
00369     }
00370     super.handleMouseEnter(e);
00371 }

void ScribbleCanvas::handleMouseExit (  MouseEvent    e )  [inline]
 

Reimplemented from ActiveCanvas. 

00375 {
00376 if (DEBUG_EVENTS)
00377 OutputStreamArea.println("SC handleMouseExit (" + getID() + "): " + e.getPoint());
00378     mouseInside = false;
00379 
00380     if (inDrawMode(curMode)) {
00381         return;
00382     }
00383     super.handleMouseExit(e);
00384 }

void ScribbleCanvas::handleMouseMove (  MouseEvent    e )  [inline]
 

Interface for MouseMotionListener events, called by LayeredCanvasPane.

Reimplemented from ActiveCanvas. 

00388 {
00389 if (DEBUG_EVENTS)
00390 OutputStreamArea.println("SC handleMouseMove (" + getID() + "): " + e.getPoint());
00391     if (!mouseInside || curMode == FIG_DELETE ||
00392                         curMode == FIG_DEL_POINT) {
00393         return;
00394     } else if (curMode == FIG_MOVE || curMode == FIG_COPY) {
00395         if (isDrawing()) {
00396             df.handleFullMove(e);
00397 if (DEBUG_EVENTS)
00398 OutputStreamArea.println("MOVE / COPY CONTINUED (MOVED)");
00399         }
00400         return;
00401     } else if (curMode == FIG_RESIZE || curMode == FIG_MOV_POINT) {
00402         if (isDrawing()) {
00403             df.handlePointMove(e);
00404 if (DEBUG_EVENTS)
00405 OutputStreamArea.println("RESIZE / RESHAPE CONTINUED (MOVED)");
00406         }
00407         return;
00408     } else if (inDrawMode(curMode)) {
00409         if (isDrawing()) {
00410             df.handleDrawMove(e);
00411 if (DEBUG_EVENTS)
00412 OutputStreamArea.println("DRAW CONTINUED (MOVED)");
00413         }
00414         return;
00415     }
00416     super.handleMouseMove(e);
00417 }

void ScribbleCanvas::handleMouseDrag (  MouseEvent    e )  [inline]
 

Reimplemented from IcsCanvas. 

00421 {
00422 if (DEBUG_EVENTS)
00423 OutputStreamArea.println("SC handleMouseDrag (" + getID() + "): " + e.getPoint());
00424     if (curMode == FIG_DELETE || curMode == FIG_DEL_POINT) {
00425         return;
00426     } else if (curMode == FIG_MOVE || curMode == FIG_COPY) {
00427         if (isDrawing()) {
00428             df.handleFullMove(e);
00429 if (DEBUG_EVENTS)
00430 OutputStreamArea.println("MOVE / COPY CONTINUED (DRAGGED)");
00431         }
00432         return;
00433     } else if (curMode == FIG_RESIZE || curMode == FIG_MOV_POINT) {
00434         if (isDrawing()) {
00435             df.handlePointMove(e);
00436 if (DEBUG_EVENTS)
00437 OutputStreamArea.println("RESIZE / RESHAPE CONTINUED (DRAGGED)");
00438         }
00439         return;
00440     } else if (inDrawMode(curMode)) {
00441         if (isDrawing()) {
00442             df.handleDrawMove(e);
00443 if (DEBUG_EVENTS)
00444 OutputStreamArea.println("DRAW CONTINUED (DRAGGED)");
00445         }
00446         return;
00447     }
00448     super.handleMouseDrag(e);
00449 }

void ScribbleCanvas::drawImages (  Graphics    g )  [inline, protected]
  

00460 {
00461     // clear canvas...
00462 
00463     if (isOpaque()) {
00464         g.setColor(getBackgroundColor());
00465         Dimension d = getDimensionCCS();
00466         g.fillRect(0, 0, d.width, d.height);
00467     }
00468 
00469     // ... and draw images.
00470 
00471     for (int i=0; i < _repository.nrOfObjectsAt(IMAGE_LAYER); i++) {
00472         getObject(IMAGE_LAYER, i).draw(g);
00473     }
00474 }

void ScribbleCanvas::drawObjects (  Graphics    g )  [inline, protected]
  

00478 {
00479     for (int i=0; i < _repository.nrOfObjectsAt(FIGURE_LAYER); i++) {
00480         getObject(FIGURE_LAYER, i).draw(g);
00481     }
00482 }

void ScribbleCanvas::zoomObjects (  double    zoomValue )  [inline, protected]
  

00486 {
00487     for (int i=0; i < _repository.nrOfObjectsAt(IMAGE_LAYER); i++) {
00488         getObject(IMAGE_LAYER, i).setZoomFactor(zoomValue);
00489     }
00490     for (int i=0; i < _repository.nrOfObjectsAt(FIGURE_LAYER); i++) {
00491         getObject(FIGURE_LAYER, i).setZoomFactor(zoomValue);
00492     }
00493 }

ScribbleFigure ScribbleCanvas::createDrawFigure (  int    x,
int    y
)  [inline, protected]
  

00497 {
00498     int mode  = CanvasObject.XOR_MODE;
00499     Color col = ScribbleFigure.NO_COLOR;
00500 
00501     switch (curMode) {
00502         case SELECTION        :
00503                 return null;
00504         case DRAW_POINT       :
00505                 return (new CanvasPoint(x, y, mode, col, getZoomFactor()));
00506         case DRAW_LINE        :
00507                 return (new CanvasLine(x, y, x, y, mode,
00508                                         col, getZoomFactor()));
00509         case DRAW_SQUARE      :
00510                 return (new CanvasRectangle(x, y, 0, 0, mode,
00511                                         col, true, getZoomFactor()));
00512         case DRAW_RECTANGLE   :
00513                 return (new CanvasRectangle(x, y, 0, 0, mode,
00514                                         col, false, getZoomFactor()));
00515         case DRAW_CIRCLE      :
00516                 return (new CanvasOval(x, y, 0, 0, mode,
00517                                         col, true, getZoomFactor()));
00518         case DRAW_OVAL        :
00519                 return (new CanvasOval(x, y, 0, 0, mode,
00520                                         col, false, getZoomFactor()));
00521         case DRAW_POLYLINE    :
00522         case DRAW_POLYGON     :
00523         case DRAW_FREE_OPEN   :
00524         case DRAW_FREE_CLOSED :
00525                 int[] xs = { x };
00526                 int[] ys = { y };
00527                 return (new CanvasPolyline(xs, ys, 1, mode,
00528                                            col, false, getZoomFactor()));
00529         case DRAW_ARROW       :
00530                 return (new CanvasArrow(x, y, 0, 0, mode,
00531                                         col, false, getZoomFactor()));
00532         case DRAW_STRING      :
00533                 return (new CanvasString("This is a test", x, y, mode,
00534                                         col, getZoomFactor()));
00535         default : return null;
00536     }
00537 }

void ScribbleCanvas::handleFigureDraw (  MouseEvent    e )  [inline, protected]
  

00544 {
00545     if (!isDrawing()) {             // Start draw...
00546         ScribbleFigure fig = createDrawFigure(e.getX(), e.getY());
00547         df = new DrawField(this.getGraphics(), fig);
00548 
00549         if (curMode == DRAW_FREE_OPEN ||
00550             curMode == DRAW_FREE_CLOSED) {
00551             df.setContinuous(true);
00552         }
00553         df.handleDrawStart(e);
00554 if (DEBUG_EVENTS)
00555 OutputStreamArea.println("DRAW STARTED");
00556         if (curMode != DRAW_POINT) {
00557             return;
00558         }
00559 
00560     } else if (e.isMetaDown()) {    // Cancel draw...
00561         df.handleAbort();
00562         df = null;
00563 if (DEBUG_EVENTS)
00564 OutputStreamArea.println("DRAW CANCELLED");
00565         return;
00566 
00567     } else if (df.getCurFigure().isComplex() &&
00568                 !e.isAltDown()) {   // Continue draw (complex)...
00569         df.handleDrawStart(e);
00570 if (DEBUG_EVENTS)
00571 OutputStreamArea.println("DRAW CONTINUED (COMPLEX OBJECT; POINT ADDED)");
00572         return;
00573     }
00574                                     // Finish draw...
00575     df.handleDrawStop(e);
00576     ScribbleFigure newFigure = df.getDrawnFigure();
00577     df = null;
00578     if (newFigure == null) {
00579         return;
00580     }
00581     newFigure.setDrawMode(CanvasObject.COPY_MODE);
00582     if (newFigure instanceof CanvasPolyline) {
00583         ((CanvasPolyline)newFigure).removeRedundantPoints();
00584     }
00585     if (curMode == DRAW_POLYGON || curMode == DRAW_FREE_CLOSED) {
00586         ((CanvasPolyline)newFigure).setClosed(true);
00587     }
00588 
00589     if (getZoomFactor() == STD_ZOOM) {
00590         newFigure.doPixelFit(getZoomFactor());
00591     }
00592 
00593     addObject(newFigure);
00594 if (DEBUG_EVENTS)
00595 OutputStreamArea.println("DRAW FINISHED");
00596     if (_editUser != null)
00597         _editUser.objectCreated(this, newFigure,
00598                                 _repository.getObjectID(newFigure));
00599 //        repaint();
00600 }

void ScribbleCanvas::handleFigureDelete (  MouseEvent    e )  [inline, protected]
  

00604 {
00605     int index;
00606 
00607     if (popUpHandling) {
00608         if (selIndex < 0) {
00609             return;
00610         }
00611         index = selIndex;
00612     } else if ((index = selector.handleSelection(e)) < 0) {
00613         return;
00614     }
00615 
00616     if (popUpHandling) {
00617         int objID = _repository.getObjectID(selLayer, index);
00618         if (_editUser != null)
00619             _editUser.objectDeleted(this, _repository.get(selLayer, index), objID);
00620         removeObject(selLayer, index);
00621     } else {
00622         int objID = _repository.getObjectID(FIGURE_LAYER, index);
00623         if (_editUser != null)
00624             _editUser.objectDeleted(this, _repository.get(FIGURE_LAYER, index), objID);
00625         removeObject(FIGURE_LAYER, index);
00626     }
00627 
00628     if (!popUpHandling) {
00629         selector.refill(_repository.getAllObjectsAt(FIGURE_LAYER));
00630     } else {
00631         curMode = SELECTION;
00632         popUpHandling = false;
00633         unselectObject();
00634     }
00635 if (DEBUG_EVENTS)
00636 OutputStreamArea.println("DELETE PERFORMED");
00637     repaint();
00638 }

void ScribbleCanvas::handleFigureDelPoint (  MouseEvent    e )  [inline, protected]
  

00642 {
00643     int point;
00644 
00645     if (((oldIndex = selector.handleSelection(e)) < 0) ||
00646         ((point = selector.getSelectedPoint()) < 0)) {
00647         return;
00648     }
00649 
00650     if (popUpHandling) {
00651         if (selIndex < 0) {
00652             return;
00653         }
00654         oldIndex = selIndex;
00655     }
00656 
00657     oldFigure = (ScribbleFigure)getObject(FIGURE_LAYER, oldIndex);
00658     if (!oldFigure.isComplex()) {
00659         return;
00660     }
00661 
00662     ScribbleFigure cf = (ScribbleFigure)oldFigure.clone();
00663     if (!cf.removePoint(point)) {
00664         return;
00665     }
00666     oldObjID = _repository.getObjectID(FIGURE_LAYER, oldIndex);
00667     removeObject(FIGURE_LAYER, oldIndex);
00668     addObject(cf, oldIndex, oldObjID);
00669 if (DEBUG_EVENTS)
00670 OutputStreamArea.println("OBJECT POINT DELETED; id = " + oldObjID + "; point = " + point);
00671     if (_editUser != null)
00672         _editUser.objectReshaped(this, cf, oldObjID, point);
00673     oldFigure = null;
00674     oldIndex  = -1;
00675     oldObjID  = -1;
00676 
00677     if (!popUpHandling) {
00678         selector.refill(_repository.getAllObjectsAt(FIGURE_LAYER));
00679     } else {
00680         Vector objvec = new Vector();
00681         objvec.addElement(getObject(selLayer, selIndex));
00682         selector.refill(objvec);
00683     }
00684 if (DEBUG_EVENTS)
00685 OutputStreamArea.println("DELETE POINT PERFORMED");
00686 //        repaint();
00687 }

void ScribbleCanvas::handleFigureMoveCopy (  MouseEvent    e )  [inline, protected]
  

00691 {
00692     if (!isDrawing()) {         // Start move or copy...
00693         int index;
00694 
00695         if (popUpHandling) {
00696             if (selIndex < 0) {
00697                 return;
00698             }
00699             index = selIndex;
00700         } else if ((index = selector.handleSelection(e)) < 0) {
00701             return;
00702         }
00703 
00704         oldFigure = (ScribbleFigure)getObject(FIGURE_LAYER, index);
00705         oldIndex  = index;
00706         oldObjID  = _repository.getObjectID(FIGURE_LAYER, oldIndex);
00707         ScribbleFigure cf = (ScribbleFigure)oldFigure.clone();
00708         cf.setDrawMode(CanvasObject.XOR_MODE);
00709         if (curMode == FIG_MOVE) {
00710             removeObject(FIGURE_LAYER, index);
00711         }
00712         df = new DrawField(this.getGraphics(), cf);
00713         df.handleFullMoveStart(e);
00714 if (DEBUG_EVENTS)
00715 OutputStreamArea.println("MOVE / COPY STARTED");
00716 
00717     } else {
00718         if (e.isMetaDown()) {   // Cancel move or copy (right mouse)...
00719             df.handleAbort();
00720             if (curMode == FIG_MOVE && oldFigure != null) {
00721                 addObject(oldFigure, oldIndex, oldObjID);
00722             }
00723 if (DEBUG_EVENTS)
00724 OutputStreamArea.println("MOVE / COPY CANCELLED");
00725 
00726         } else {                // Finish move or copy...
00727             df.handleFullMoveStop(e);
00728             ScribbleFigure newFigure = df.getDrawnFigure();
00729             if (newFigure != null) {
00730                 if (getZoomFactor() == STD_ZOOM) {
00731                     newFigure.doPixelFit(getZoomFactor());
00732                 }
00733                 newFigure.setDrawMode(ScribbleFigure.COPY_MODE);
00734                 if (curMode == FIG_MOVE) {
00735                     addObject(newFigure, oldIndex, oldObjID);
00736                     if (_editUser != null)
00737                         _editUser.objectMoved(this, newFigure, oldObjID);
00738                 } else {
00739                     addObject(newFigure);
00740                     if (_editUser != null)
00741                         _editUser.objectCreated(this, newFigure,
00742                                         _repository.getObjectID(newFigure));
00743                 }
00744             }
00745 if (DEBUG_EVENTS)
00746 OutputStreamArea.println("MOVE / COPY FINISHED");
00747         }
00748         df = null;
00749         oldFigure = null;
00750         oldIndex = -1;
00751 
00752         if (popUpHandling) {
00753             popUpHandling = false;
00754             curMode = SELECTION;
00755             unselectObject();
00756         }
00757     }
00758 
00759     if (inFigureMode(curMode) && !popUpHandling) {
00760         selector.refill(_repository.getAllObjectsAt(FIGURE_LAYER));
00761     }
00762 //        repaint();
00763 }

void ScribbleCanvas::handleFigureModify (  MouseEvent    e )  [inline, protected]
  

00767 {
00768     if (!isDrawing()) {         // Start modify...
00769         int index;
00770 
00771         if (((index = selector.handleSelection(e)) < 0) ||
00772             ((selPoint = selector.getSelectedPoint()) < 0)) {
00773             return;
00774         }
00775         if (popUpHandling) {
00776             if (selIndex < 0) {
00777                 return;
00778             }
00779             index = selIndex;
00780             selector = null;
00781         }
00782 
00783         ScribbleFigure cf;
00784         oldFigure = (ScribbleFigure)(getObject(FIGURE_LAYER, index));
00785         oldIndex  = index;
00786         oldObjID  = _repository.getObjectID(FIGURE_LAYER, oldIndex);
00787 
00788         if (oldFigure.isComplex() && curMode == FIG_RESIZE ||
00789             oldFigure instanceof CanvasFigureAggregate) {
00790 
00791             // use rectangle for aggregate / complex figure resize.
00792 
00793             cf = new CanvasRectangle(oldFigure.getX1Ccs(),
00794                                      oldFigure.getY1Ccs(), oldFigure.getWidthCcs(),
00795                                      oldFigure.getHeightCcs(), oldFigure.getDrawMode(),
00796                                      oldFigure.getColor(),
00797                                      false, getZoomFactor());
00798         } else {
00799             cf = (ScribbleFigure)oldFigure.clone();
00800         }
00801 
00802         cf.setDrawMode(CanvasObject.XOR_MODE);
00803         removeObject(FIGURE_LAYER, index);
00804         df = new DrawField(this.getGraphics(), cf);
00805         df.handlePointMoveStart(e, selPoint);
00806 if (DEBUG_EVENTS)
00807 OutputStreamArea.println("RESIZE / RESHAPE STARTED");
00808 
00809     } else {
00810         if (e.isMetaDown()) {   // Cancel modify (right mouse)...
00811             df.handleAbort();
00812             if (popUpHandling) {
00813                 addObject(oldFigure, oldIndex, oldObjID);
00814                 Vector objvec = new Vector();
00815                 objvec.addElement(oldFigure);
00816                 if (curMode == FIG_RESIZE) {
00817                     selector = new Selector(this.getGraphics(),
00818                                             objvec, Selector.BOXES);
00819                 } else {
00820                     selector = new Selector(this.getGraphics(),
00821                                             objvec, Selector.COMPLEX);
00822                 }
00823             } else {
00824                 addObject(oldFigure, oldIndex, oldObjID);
00825             }
00826 if (DEBUG_EVENTS)
00827 OutputStreamArea.println("RESIZE / RESHAPE CANCELLED");
00828 
00829 
00830         } else {                // Finish modify...
00831             df.handlePointMoveStop(e);
00832             ScribbleFigure newFigure = df.getDrawnFigure();
00833 
00834             if (newFigure != null) {
00835                 if (oldFigure.isComplex() && curMode == FIG_RESIZE ||
00836                     oldFigure instanceof CanvasFigureAggregate) {
00837                     oldFigure.setPosition(newFigure.getX1Ccs(), newFigure.getY1Ccs());
00838                     oldFigure.setDimension(newFigure.getWidthCcs(), newFigure.getHeightCcs());
00839                 } else {
00840                     oldFigure.changePoint(selPoint, e.getX(), e.getY());
00841 
00842                     if (oldFigure instanceof CanvasArrow) {
00843                         oldFigure.setPosition(newFigure.getStartXCcs(),
00844                                               newFigure.getStartYCcs());
00845                     } else {
00846                         oldFigure.setPosition(newFigure.getX1Ccs(),
00847                                               newFigure.getY1Ccs());
00848                     }
00849                 }
00850                 if (getZoomFactor() == STD_ZOOM) {
00851                     oldFigure.doPixelFit(getZoomFactor());
00852                 }
00853 
00854                 if (popUpHandling) {
00855                     Vector objvec = new Vector();
00856                     addObject(oldFigure, oldIndex, oldObjID);
00857                     objvec.addElement((ScribbleFigure)oldFigure.clone());
00858                     if (curMode == FIG_RESIZE) {
00859                         selector = new Selector(this.getGraphics(),
00860                                                 objvec, Selector.BOXES);
00861                         if (_editUser != null)
00862                             _editUser.objectResized(this,oldFigure, oldObjID);
00863                     } else {
00864                         selector = new Selector(this.getGraphics(),
00865                                                 objvec, Selector.COMPLEX);
00866                         if (_editUser != null)
00867                             _editUser.objectReshaped(this, oldFigure,
00868                                                      oldObjID, selPoint);
00869                     }
00870 
00871                 } else {
00872                     addObject((ScribbleFigure)oldFigure.clone(), oldIndex, oldObjID);
00873                     if (curMode == FIG_RESIZE) {
00874                         if (_editUser != null)
00875                             _editUser.objectResized(this,
00876                                                     _repository.get(oldObjID),
00877                                                     oldObjID);
00878                     } else {
00879                         if (_editUser != null)
00880                             _editUser.objectReshaped(this,
00881                                                      _repository.get(oldObjID),
00882                                                      oldObjID,
00883                                                      selPoint);
00884                     }
00885                 }
00886             }
00887         }
00888         df = null;
00889         oldFigure = null;
00890         oldIndex = -1;
00891 if (DEBUG_EVENTS)
00892 OutputStreamArea.println("RESIZE / RESHAPE FINISHED");
00893     }
00894 
00895     if (inFigureMode(curMode) && !popUpHandling) {
00896         selector.refill(_repository.getAllObjectsAt(FIGURE_LAYER));
00897     }
00898 //        repaint();
00899 }

boolean ScribbleCanvas::isDrawing (    )  [inline, protected]
  

00906 {
00907     return (df != null);
00908 }

boolean ScribbleCanvas::inDrawMode (  int    mode )  [inline, protected]
  

00912 {
00913     switch (mode) {
00914         case DRAW_POINT       :
00915         case DRAW_LINE        :
00916         case DRAW_SQUARE      :
00917         case DRAW_RECTANGLE   :
00918         case DRAW_CIRCLE      :
00919         case DRAW_OVAL        :
00920         case DRAW_POLYLINE    :
00921         case DRAW_POLYGON     :
00922         case DRAW_FREE_OPEN   :
00923         case DRAW_FREE_CLOSED :
00924         case DRAW_ARROW       :
00925         case DRAW_STRING      : return true;
00926         default               : return false;
00927     }
00928 }

boolean ScribbleCanvas::inFigureMode (  int    mode )  [inline, protected]
  

00932 {
00933     switch (mode) {
00934         case FIG_DELETE       :
00935         case FIG_COPY         :
00936         case FIG_MOVE         :
00937         case FIG_RESIZE       :
00938         case FIG_MOV_POINT    :
00939         case FIG_ADD_POINT    :
00940         case FIG_DEL_POINT    : return true;
00941         default               : return false;
00942     }
00943 }

boolean ScribbleCanvas::inComplexSelectionMode (  int    mode )  [inline, protected]
  

00947 {
00948     switch (mode) {
00949         case FIG_MOV_POINT    :
00950         case FIG_ADD_POINT    :
00951         case FIG_DEL_POINT    : return true;
00952         default               : return false;
00953     }
00954 }

void ScribbleCanvas::selectObject (    )  [inline, protected]
  

00958 {
00959     selLayer = lastLayer;
00960     selIndex = lastIndex;
00961     double[] ics_selXY = { lastX, lastY };
00962     int[]    ccs_selXY = Converter.ICStoCCS(ics_selXY, getZoomFactor());
00963     selX = ccs_selXY[0];
00964     selY = ccs_selXY[1];
00965 }

void ScribbleCanvas::unselectObject (    )  [inline, protected]
  

00969 {
00970     selLayer = -1;
00971     selIndex = -1;
00972     selX     = -1;
00973     selY     = -1;
00974 }

void ScribbleCanvas::popUpObjectMenu (    )  [inline, protected]
  

00981 {
00982     CanvasObject obj = getObject(selLayer, selIndex);
00983     Vector v = obj.getVisualChangeMethods();
00984     methods = new CallableMethod[v.size()];
00985     for (int i=0; i<v.size(); i++) {
00986         methods[i] = (CallableMethod) v.get(i);
00987     }
00988     popUpHandling = true;
00989     PopMenu pm = new PopMenu(this);
00990 
00991     // Add class-name of Object
00992 
00993     String  name = obj.getClass().getName();
00994     int     index = name.lastIndexOf('.');
00995     name = "< " + name.substring(index+1) + " >";
00996     pm.addLabel(name);
00997     pm.setEnabled(false, name);
00998     pm.addSeparator();
00999 
01000     if (obj.getInputSource() == CanvasObject.INP_USER) {
01001         String[] labels = new String[] { "Copy", "Move", "Resize",
01002                                          "Move Point", "Delete Point" };
01003         pm.addLabels(labels);
01004         if (!((ScribbleFigure)obj).isResizeable()) {
01005             pm.setEnabled(false, "Resize");
01006         }
01007         if (!((ScribbleFigure)obj).isComplex()) {
01008             pm.setEnabled(false, "Move Point");
01009             pm.setEnabled(false, "Delete Point");
01010         }
01011         pm.insertSeparator(5);
01012         pm.addSeparator();
01013     }
01014 
01015     JMenu runmenu = new JMenu("Run");
01016     pm.addMenu(runmenu);
01017     if (methods != null && methods.length > 0) {
01018         for (int i=0; i<methods.length; i++) {
01019             JMenuItem mi = null;
01020             if(methods[i] instanceof CallableProperty) {
01021                 CallableProperty prop = (CallableProperty)methods[i];
01022                 if(prop.getArgTypes()[0] == "boolean") {
01023                     boolean value = ((Boolean)prop.getPropertyValue()).booleanValue();
01024                     mi = new JCheckBoxMenuItem(prop.getPropertyName(), value);
01025                     mi.addActionListener(new JavaFuncAction("", obj,
01026                         prop, this, "handleJavaFuncDialogOK",
01027                         new Object[] {new Boolean(!value)}));
01028                 }
01029                 else if(prop.getArgTypes()[0] == "Color") {
01030                     JMenu subMenu = new JMenu(prop.getPropertyName());
01031                     mi = subMenu;
01032                     for(int cl=0; cl<ExtMenuBar.colors.length; cl++) {
01033                         JMenuItem cmi = ExtMenuBar.colorMenuItem(cl);
01034                         mi.add(cmi);
01035                         cmi.addActionListener(new JavaFuncAction("", obj,
01036                             prop, this, "handleJavaFuncDialogOK",
01037                             new Object[] { ExtMenuBar.colors[cl] }));
01038                     }
01039                 }
01040             }
01041 
01042             if(mi == null) {
01043                 mi = new JMenuItem(methods[i].getMethodName());
01044                 mi.setActionCommand(methods[i].getMethodName());
01045                 mi.addActionListener(this);
01046             }
01047             runmenu.add(mi);
01048         }
01049     } else {
01050         pm.setEnabled(false, "Run");
01051     }
01052     pm.addSeparator();
01053 
01054 //JMenu saMM = new SaMethodMenu("HxImageRep", this);
01055 //pm.addMenu(saMM);
01056 //pm.addSeparator();
01057 
01058     pm.addLabel("Delete");
01059     pm.addSeparator();
01060     pm.addLabel("Cancel");
01061     pm.show(selX, selY);
01062 }

Member Data Documentation

final int ScribbleCanvas::IMAGE_LAYER = 0 [static, protected]
 

final int ScribbleCanvas::FIGURE_LAYER = 1 [static, protected]
 

final int ScribbleCanvas::NR_OF_LAYERS = 2 [static, protected]
 

final String ScribbleCanvas::CANVAS_IMAGE_CLASS = "HxJava.CanvasObject.CanvasImage" [static, protected]
 

final String ScribbleCanvas::CANVAS_FIGURE_CLASS = "HxJava.CanvasObject.ScribbleFigure" [static, protected]
 

DrawField ScribbleCanvas::df = null [protected]
 

Selector ScribbleCanvas::selector = null [protected]
 

ScribbleFigure ScribbleCanvas::oldFigure = null [protected]
 

boolean ScribbleCanvas::mouseInside = false [protected]
 

boolean ScribbleCanvas::popUpHandling = false [protected]
 

int ScribbleCanvas::curMode = SELECTION [protected]
 

int ScribbleCanvas::selPoint = -1 [protected]
 

int ScribbleCanvas::selLayer = -1 [protected]
 

int ScribbleCanvas::selIndex = -1 [protected]
 

int ScribbleCanvas::oldIndex = -1 [protected]
 

int ScribbleCanvas::oldObjID = -1 [protected]
 

int ScribbleCanvas::selX = -1 [protected]
 

int ScribbleCanvas::selY = -1 [protected]
 

CallableMethod [] ScribbleCanvas::methods = null [protected]
 

The documentation for this class was generated from the following file:
Generated on Mon Jan 27 15:11:25 2003 for JavaReference by doxygen1.2.12 written by Dimitri van Heesch, © 1997-2001