wxPython/samples/ide/activegrid/tool/AbstractEditor.py

   1 #----------------------------------------------------------------------------
   2 # Name:         AbstractEditor.py
   3 # Purpose:      Non-text editor for DataModel and Process
   4 #
   5 # Author:       Peter Yared, Morgan Hua
   6 #
   7 # Created:      7/28/04
   8 # CVS-ID:       $Id$
   9 # Copyright:    (c) 2004-2005 ActiveGrid, Inc.
  10 # License:      wxWindows License
  11 #----------------------------------------------------------------------------
  12
  13
  14 import wx
  15 import wx.lib.docview
  16 import wx.lib.ogl as ogl
  17 import PropertyService
  18 _ = wx.GetTranslation
  19
  20
  21 SELECT_BRUSH = wx.Brush("BLUE", wx.SOLID)
  22 SHAPE_BRUSH = wx.Brush("WHEAT", wx.SOLID)
  23 LINE_BRUSH = wx.BLACK_BRUSH
  24 INACTIVE_SELECT_BRUSH = wx.Brush("LIGHT BLUE", wx.SOLID)
  25
  26
  27 def GetRawModel(model):
  28     if hasattr(model, "GetRawModel"):
  29         rawModel = model.GetRawModel()
  30     else:
  31         rawModel = model
  32     return rawModel
  33
  34
  35 class CanvasView(wx.lib.docview.View):
  36
  37
  38     #----------------------------------------------------------------------------
  39     # Overridden methods
  40     #----------------------------------------------------------------------------
  41
  42
  43     def __init__(self, brush = SHAPE_BRUSH):
  44         wx.lib.docview.View.__init__(self)
  45         self._brush = brush
  46         self._canvas = None
  47         self._pt1 = None
  48         self._pt2 = None
  49         self._needEraseLasso = False
  50         self._propShape = None
  51
  52
  53     def OnCreate(self, doc, flags):
  54         frame = wx.GetApp().CreateDocumentFrame(self, doc, flags)
  55         frame.Show()
  56         sizer = wx.BoxSizer()
  57         self._CreateCanvas(frame)
  58         sizer.Add(self._canvas, 1, wx.EXPAND, 0)
  59         frame.SetSizer(sizer)
  60         frame.Layout()
  61         self.Activate()
  62         return True
  63
  64
  65     def OnActivateView(self, activate, activeView, deactiveView):
  66         if activate and self._canvas:
  67             # In MDI mode just calling set focus doesn't work and in SDI mode using CallAfter causes an endless loop
  68             if self.GetDocumentManager().GetFlags() & wx.lib.docview.DOC_SDI:
  69                 self._canvas.SetFocus()
  70             else:
  71                 wx.CallAfter(self._canvas.SetFocus)
  72
  73
  74     def OnFocus(self, event):
  75         self._canvas.SetFocus()
  76         self.FocusColorPropertyShape(True)
  77         event.Skip()
  78
  79
  80     def OnKillFocus(self, event):
  81         self.FocusColorPropertyShape(False)
  82         event.Skip()
  83
  84
  85     def OnClose(self, deleteWindow = True):
  86         statusC = wx.GetApp().CloseChildDocuments(self.GetDocument())
  87         statusP = wx.lib.docview.View.OnClose(self, deleteWindow = deleteWindow)
  88         if hasattr(self, "ClearOutline"):
  89             wx.CallAfter(self.ClearOutline)  # need CallAfter because when closing the document, it is Activated and then Close, so need to match OnActivateView's CallAfter
  90         if not (statusC and statusP):
  91             return False
  92         self.Activate(False)
  93         if deleteWindow and self.GetFrame():
  94             self.GetFrame().Destroy()
  95         return True
  96
  97
  98     def _CreateCanvas(self, parent):
  99         self._canvas = ogl.ShapeCanvas(parent)
 100         wx.EVT_LEFT_DOWN(self._canvas, self.OnLeftClick)
 101         wx.EVT_LEFT_UP(self._canvas, self.OnLeftUp)
 102         wx.EVT_MOTION(self._canvas, self.OnLeftDrag)
 103         wx.EVT_LEFT_DCLICK(self._canvas, self.OnLeftDoubleClick)
 104         wx.EVT_KEY_DOWN(self._canvas, self.OnKeyPressed)
 105
 106         # need this otherwise mouse clicks don't set focus to this view
 107         wx.EVT_LEFT_DOWN(self._canvas, self.OnFocus)
 108         wx.EVT_LEFT_DCLICK(self._canvas, self.OnFocus)
 109         wx.EVT_RIGHT_DOWN(self._canvas, self.OnFocus)
 110         wx.EVT_RIGHT_DCLICK(self._canvas, self.OnFocus)
 111         wx.EVT_MIDDLE_DOWN(self._canvas, self.OnFocus)
 112         wx.EVT_MIDDLE_DCLICK(self._canvas, self.OnFocus)
 113
 114         wx.EVT_KILL_FOCUS(self._canvas, self.OnKillFocus)
 115         wx.EVT_SET_FOCUS(self._canvas, self.OnFocus)
 116
 117         maxWidth = 2000
 118         maxHeight = 16000
 119         self._canvas.SetScrollbars(20, 20, maxWidth / 20, maxHeight / 20)
 120
 121         self._canvas.SetBackgroundColour(wx.WHITE)
 122         self._diagram = ogl.Diagram()
 123         self._canvas.SetDiagram(self._diagram)
 124         self._diagram.SetCanvas(self._canvas)
 125
 126
 127     def OnKeyPressed(self, event):
 128         key = event.KeyCode()
 129         if key == wx.WXK_DELETE:
 130             self.OnClear(event)
 131         else:
 132             event.Skip()
 133
 134
 135     def OnLeftClick(self, event):
 136         self.EraseRubberBand()
 137
 138         dc = wx.ClientDC(self._canvas)
 139         self._canvas.PrepareDC(dc)
 140
 141         # keep track of mouse down for group select
 142         self._pt1 = event.GetLogicalPosition(dc)  # this takes into account scrollbar offset
 143         self._pt2 = None
 144
 145         shape = self._canvas.FindShape(self._pt1[0], self._pt1[1])[0]
 146         if shape:
 147             self.BringToFront(shape)
 148
 149             self._pt1 = None
 150             event.Skip()  # pass on event to shape handler to take care of selection
 151
 152             return
 153         elif event.ControlDown() or event.ShiftDown():    # extend select, don't deselect
 154             pass
 155         else:
 156             # click on empty part of canvas, deselect everything
 157             needRefresh = False
 158             for shape in self._diagram.GetShapeList():
 159                 if hasattr(shape, "GetModel"):
 160                     if shape.Selected():
 161                         needRefresh = True
 162                         shape.Select(False, dc)
 163             if needRefresh:
 164                 self._canvas.Redraw(dc)
 165
 166             self.SetPropertyModel(None)
 167
 168         if len(self.GetSelection()) == 0:
 169             self.SetPropertyShape(None)
 170
 171
 172
 173     def OnLeftDoubleClick(self, event):
 174         propertyService = wx.GetApp().GetService(PropertyService.PropertyService)
 175         if propertyService:
 176             propertyService.ShowWindow()
 177
 178
 179     def OnLeftDrag(self, event):
 180         # draw lasso for group select
 181         if self._pt1 and event.LeftIsDown():   # we are in middle of lasso selection
 182             self.EraseRubberBand()
 183
 184             dc = wx.ClientDC(self._canvas)
 185             self._canvas.PrepareDC(dc)
 186             self._pt2 = event.GetLogicalPosition(dc)  # this takes into account scrollbar offset
 187             self.DrawRubberBand()
 188         else:
 189             event.Skip()
 190
 191
 192     def OnLeftUp(self, event):
 193         # do group select
 194         if self._needEraseLasso:
 195             self.EraseRubberBand()
 196
 197             dc = wx.ClientDC(self._canvas)
 198             self._canvas.PrepareDC(dc)
 199             x1, y1 = self._pt1
 200             x2, y2 = event.GetLogicalPosition(dc)  # this takes into account scrollbar offset
 201
 202             tol = self._diagram.GetMouseTolerance()
 203             if abs(x1 - x2) > tol or abs(y1 - y2) > tol:
 204                 # make sure x1 < x2 and y1 < y2 to make comparison test easier
 205                 if x1 > x2:
 206                     temp = x1
 207                     x1 = x2
 208                     x2 = temp
 209                 if y1 > y2:
 210                     temp = y1
 211                     y1 = y2
 212                     y2 = temp
 213
 214                 for shape in self._diagram.GetShapeList():
 215                     if not shape.GetParent() and hasattr(shape, "GetModel"):  # if part of a composite, don't select it
 216                         x, y = shape.GetX(), shape.GetY()
 217                         width, height = shape.GetBoundingBoxMax()
 218                         selected = x1 < x - width/2 and x2 > x + width/2 and y1 < y - height/2 and y2 > y + height/2
 219                         if event.ControlDown() or event.ShiftDown():    # extend select, don't deselect
 220                             if selected:
 221                                 shape.Select(selected, dc)
 222                         else:   # select items in lasso and deselect items out of lasso
 223                             shape.Select(selected, dc)
 224                 self._canvas.Redraw(dc)
 225             else:
 226                 event.Skip()
 227         else:
 228             event.Skip()
 229
 230
 231     def EraseRubberBand(self):
 232         if self._needEraseLasso:
 233             self._needEraseLasso = False
 234
 235             dc = wx.ClientDC(self._canvas)
 236             self._canvas.PrepareDC(dc)
 237             dc.SetLogicalFunction(wx.XOR)
 238             pen = wx.Pen(wx.Colour(200, 200, 200), 1, wx.SHORT_DASH)
 239             dc.SetPen(pen)
 240             brush = wx.Brush(wx.Colour(255, 255, 255), wx.TRANSPARENT)
 241             dc.SetBrush(brush)
 242             dc.ResetBoundingBox()
 243             dc.BeginDrawing()
 244
 245             x1, y1 = self._pt1
 246             x2, y2 = self._pt2
 247
 248             # make sure x1 < x2 and y1 < y2
 249             # this will make (x1, y1) = upper left corner
 250             if x1 > x2:
 251                 temp = x1
 252                 x1 = x2
 253                 x2 = temp
 254             if y1 > y2:
 255                 temp = y1
 256                 y1 = y2
 257                 y2 = temp
 258
 259             # erase previous outline
 260             dc.SetClippingRegion(x1, y1, x2 - x1, y2 - y1)
 261             dc.DrawRectangle(x1, y1, x2 - x1, y2 - y1)
 262             dc.EndDrawing()
 263
 264
 265     def DrawRubberBand(self):
 266         self._needEraseLasso = True
 267
 268         dc = wx.ClientDC(self._canvas)
 269         self._canvas.PrepareDC(dc)
 270         dc.SetLogicalFunction(wx.XOR)
 271         pen = wx.Pen(wx.Colour(200, 200, 200), 1, wx.SHORT_DASH)
 272         dc.SetPen(pen)
 273         brush = wx.Brush(wx.Colour(255, 255, 255), wx.TRANSPARENT)
 274         dc.SetBrush(brush)
 275         dc.ResetBoundingBox()
 276         dc.BeginDrawing()
 277
 278         x1, y1 = self._pt1
 279         x2, y2 = self._pt2
 280
 281         # make sure x1 < x2 and y1 < y2
 282         # this will make (x1, y1) = upper left corner
 283         if x1 > x2:
 284             temp = x1
 285             x1 = x2
 286             x2 = temp
 287         if y1 > y2:
 288             temp = y1
 289             y1 = y2
 290             y2 = temp
 291
 292         # draw outline
 293         dc.SetClippingRegion(x1, y1, x2 - x1, y2 - y1)
 294         dc.DrawRectangle(x1, y1, x2 - x1, y2 - y1)
 295         dc.EndDrawing()
 296
 297
 298     def FindParkingSpot(self, width, height):
 299         """ given a width and height, find a upper left corner where shape can be parked without overlapping other shape """
 300         offset = 30  # space between shapes
 301         x = offset
 302         y = offset
 303         maxX = 700  # max distance to the right where we'll place tables
 304         noParkingSpot = True
 305
 306         while noParkingSpot:
 307             point = self.isSpotOccupied(x, y, width, height)
 308             if point:
 309                 x = point[0] + offset
 310                 if x > maxX:
 311                     x = offset
 312                     y = point[1] + offset
 313             else:
 314                 noParkingSpot = False
 315
 316         return x, y
 317
 318
 319     def isSpotOccupied(self, x, y, width, height):
 320         """ returns None if at x,y,width,height no object occupies that rectangle,
 321             otherwise returns lower right corner of object that occupies given x,y position
 322         """
 323         x2 = x + width
 324         y2 = y + height
 325
 326         for shape in self._diagram.GetShapeList():
 327             if isinstance(shape, ogl.RectangleShape) or isinstance(shape, ogl.EllipseShape):
 328                 if shape.GetParent() and isinstance(shape.GetParent(), ogl.CompositeShape):
 329                     # skip, part of a composite shape
 330                     continue
 331
 332                 if hasattr(shape, "GetModel"):
 333                     other_x, other_y, other_width, other_height = shape.GetModel().getEditorBounds()
 334                     other_x2 = other_x + other_width
 335                     other_y2 = other_y + other_height
 336                 else:
 337                     # shapes x,y are at the center of the shape, need to transform to upper left coordinate
 338                     other_width, other_height = shape.GetBoundingBoxMax()
 339                     other_x = shape.GetX() - other_width/2
 340                     other_y = shape.GetY() - other_height/2
 341
 342                 other_x2 = other_x + other_width
 343                 other_y2 = other_y + other_height
 344                 # intersection check
 345                 if ((other_x2 < other_x or other_x2 > x) and
 346                     (other_y2 < other_y or other_y2 > y) and
 347                     (x2 < x or x2 > other_x) and
 348                     (y2 < y or y2 > other_y)):
 349                     return (other_x2, other_y2)
 350         return None
 351
 352
 353     #----------------------------------------------------------------------------
 354     # Canvas methods
 355     #----------------------------------------------------------------------------
 356
 357     def AddShape(self, shape, x = None, y = None, pen = None, brush = None, text = None, eventHandler = None):
 358         if isinstance(shape, ogl.CompositeShape):
 359             dc = wx.ClientDC(self._canvas)
 360             self._canvas.PrepareDC(dc)
 361             shape.Move(dc, x, y)
 362         else:
 363             shape.SetDraggable(True, True)
 364         shape.SetCanvas(self._canvas)
 365
 366         if x:
 367             shape.SetX(x)
 368         if y:
 369             shape.SetY(y)
 370         shape.SetCentreResize(False)
 371         if pen:
 372             shape.SetPen(pen)
 373         if brush:
 374             shape.SetBrush(brush)
 375         if text:
 376             shape.AddText(text)
 377         shape.SetShadowMode(ogl.SHADOW_RIGHT)
 378         self._diagram.AddShape(shape)
 379         shape.Show(True)
 380         if not eventHandler:
 381             eventHandler = EditorCanvasShapeEvtHandler(self)
 382         eventHandler.SetShape(shape)
 383         eventHandler.SetPreviousHandler(shape.GetEventHandler())
 384         shape.SetEventHandler(eventHandler)
 385         return shape
 386
 387
 388     def RemoveShape(self, model = None, shape = None):
 389         if not model and not shape:
 390             return
 391
 392         if not shape:
 393             shape = self.GetShape(model)
 394
 395         if shape:
 396             shape.Select(False)
 397             self._diagram.RemoveShape(shape)
 398             if isinstance(shape, ogl.CompositeShape):
 399                 shape.RemoveFromCanvas(self._canvas)
 400
 401
 402     def UpdateShape(self, model):
 403         for shape in self._diagram.GetShapeList():
 404             if hasattr(shape, "GetModel") and shape.GetModel() == model:
 405                 x, y, w, h = model.getEditorBounds()
 406                 newX = x + w / 2
 407                 newY = y + h / 2
 408                 changed = False
 409                 if isinstance(shape, ogl.CompositeShape):
 410                     if shape.GetX() != newX or shape.GetY() != newY:
 411                         dc = wx.ClientDC(self._canvas)
 412                         self._canvas.PrepareDC(dc)
 413                         shape.SetSize(w, h, True)  # wxBug: SetSize must be before Move because links won't go to the right place
 414                         shape.Move(dc, newX, newY)  # wxBug: Move must be before SetSize because links won't go to the right place
 415                         changed = True
 416                 else:
 417                     oldw, oldh = shape.GetBoundingBoxMax()
 418                     oldx = shape.GetX()
 419                     oldy = shape.GetY()
 420                     if oldw != w or oldh != h or oldx != newX or oldy != newY:
 421                         shape.SetSize(w, h)
 422                         shape.SetX(newX)
 423                         shape.SetY(newY)
 424                         changed = True
 425                 if changed:
 426                     shape.ResetControlPoints()
 427                     self._canvas.Refresh()
 428                 break
 429
 430
 431     def GetShape(self, model):
 432         for shape in self._diagram.GetShapeList():
 433             if hasattr(shape, "GetModel") and shape.GetModel() == model:
 434                 return shape
 435         return None
 436
 437
 438     def GetSelection(self):
 439         return filter(lambda shape: shape.Selected(), self._diagram.GetShapeList())
 440
 441
 442     def SetSelection(self, models, extendSelect = False):
 443         dc = wx.ClientDC(self._canvas)
 444         self._canvas.PrepareDC(dc)
 445         update = False
 446         if not isinstance(models, type([])) and not isinstance(models, type(())):
 447             models = [models]
 448         for shape in self._diagram.GetShapeList():
 449             if hasattr(shape, "GetModel"):
 450                 if shape.Selected() and not shape.GetModel() in models:  # was selected, but not in new list, so deselect, unless extend select
 451                     if not extendSelect:
 452                         shape.Select(False, dc)
 453                         update = True
 454                 elif not shape.Selected() and shape.GetModel() in models: # was not selected and in new list, so select
 455                     shape.Select(True, dc)
 456                     update = True
 457                 elif extendSelect and shape.Selected() and shape.GetModel() in models: # was selected, but extend select means to deselect
 458                     shape.Select(False, dc)
 459                     update = True
 460         if update:
 461             self._canvas.Redraw(dc)
 462
 463
 464     def BringToFront(self, shape):
 465         if shape.GetParent() and isinstance(shape.GetParent(), ogl.CompositeShape):
 466             self._diagram.RemoveShape(shape.GetParent())
 467             self._diagram.AddShape(shape.GetParent())
 468         else:
 469             self._diagram.RemoveShape(shape)
 470             self._diagram.AddShape(shape)
 471
 472
 473     def SendToBack(self, shape):
 474         if shape.GetParent() and isinstance(shape.GetParent(), ogl.CompositeShape):
 475             self._diagram.RemoveShape(shape.GetParent())
 476             self._diagram.InsertShape(shape.GetParent())
 477         else:
 478             self._diagram.RemoveShape(shape)
 479             self._diagram.InsertShape(shape)
 480
 481
 482     def ScrollVisible(self, shape):
 483         xUnit, yUnit = shape._canvas.GetScrollPixelsPerUnit()
 484         scrollX, scrollY = self._canvas.GetViewStart()  # in scroll units
 485         scrollW, scrollH = self._canvas.GetSize()  # in pixels
 486         w, h = shape.GetBoundingBoxMax() # in pixels
 487         x = shape.GetX() - w/2  # convert to upper left coordinate from center
 488         y = shape.GetY() - h/2  # convert to upper left coordinate from center
 489
 490         if x >= scrollX*xUnit and x <= scrollX*xUnit + scrollW:  # don't scroll if already visible
 491             x = -1
 492         else:
 493             x = x/xUnit
 494
 495         if y >= scrollY*yUnit and y <= scrollY*yUnit + scrollH:  # don't scroll if already visible
 496             y = -1
 497         else:
 498             y = y/yUnit
 499
 500         self._canvas.Scroll(x, y)  # in scroll units
 501
 502
 503     def SetPropertyShape(self, shape):
 504         # no need to highlight if no PropertyService is running
 505         propertyService = wx.GetApp().GetService(PropertyService.PropertyService)
 506         if not propertyService:
 507             return
 508
 509         if shape == self._propShape:
 510             return
 511
 512         if hasattr(shape, "GetPropertyShape"):
 513             shape = shape.GetPropertyShape()
 514
 515         dc = wx.ClientDC(self._canvas)
 516         self._canvas.PrepareDC(dc)
 517         dc.BeginDrawing()
 518
 519         # erase old selection if it still exists
 520         if self._propShape and self._propShape in self._diagram.GetShapeList():
 521             self._propShape.SetBrush(self._brush)
 522             if (self._propShape._textColourName in ["BLACK", "WHITE"]):  # Would use GetTextColour() but it is broken
 523                 self._propShape.SetTextColour("BLACK", 0)
 524             self._propShape.Draw(dc)
 525
 526         # set new selection
 527         self._propShape = shape
 528
 529         # draw new selection
 530         if self._propShape and self._propShape in self._diagram.GetShapeList():
 531             self._propShape.SetBrush(SELECT_BRUSH)
 532             if (self._propShape._textColourName in ["BLACK", "WHITE"]):  # Would use GetTextColour() but it is broken
 533                 self._propShape.SetTextColour("WHITE", 0)
 534             self._propShape.Draw(dc)
 535
 536         dc.EndDrawing()
 537
 538
 539     def FocusColorPropertyShape(self, gotFocus=False):
 540         # no need to change highlight if no PropertyService is running
 541         propertyService = wx.GetApp().GetService(PropertyService.PropertyService)
 542         if not propertyService:
 543             return
 544
 545         if not self._propShape:
 546             return
 547
 548         dc = wx.ClientDC(self._canvas)
 549         self._canvas.PrepareDC(dc)
 550         dc.BeginDrawing()
 551
 552         # draw deactivated selection
 553         if self._propShape and self._propShape in self._diagram.GetShapeList():
 554             if gotFocus:
 555                 self._propShape.SetBrush(SELECT_BRUSH)
 556             else:
 557                 self._propShape.SetBrush(INACTIVE_SELECT_BRUSH)
 558             if (self._propShape._textColourName in ["BLACK", "WHITE"]):  # Would use GetTextColour() but it is broken
 559                 self._propShape.SetTextColour("WHITE", 0)
 560             self._propShape.Draw(dc)
 561
 562         dc.EndDrawing()
 563
 564
 565     #----------------------------------------------------------------------------
 566     # Property Service methods
 567     #----------------------------------------------------------------------------
 568
 569     def GetPropertyModel(self):
 570         if hasattr(self, "_propModel"):
 571             return self._propModel
 572         return None
 573
 574
 575     def SetPropertyModel(self, model):
 576         # no need to set the model if no PropertyService is running
 577         propertyService = wx.GetApp().GetService(PropertyService.PropertyService)
 578         if not propertyService:
 579             return
 580
 581         if hasattr(self, "_propModel") and model == self._propModel:
 582             return
 583
 584         self._propModel = model
 585         propertyService.LoadProperties(self._propModel, self.GetDocument())
 586
 587
 588 class EditorCanvasShapeMixin:
 589
 590     def GetModel(self):
 591         return self._model
 592
 593
 594     def SetModel(self, model):
 595         self._model = model
 596
 597
 598 class EditorCanvasShapeEvtHandler(ogl.ShapeEvtHandler):
 599
 600     """ wxBug: Bug in OLG package.  With wxShape.SetShadowMode() turned on, when we set the size,
 601         the width/height is larger by 6 pixels.  Need to subtract this value from width and height when we
 602         resize the object.
 603     """
 604     SHIFT_KEY = 1
 605     CONTROL_KEY = 2
 606
 607     def __init__(self, view):
 608         ogl.ShapeEvtHandler.__init__(self)
 609         self._view = view
 610
 611
 612     def OnLeftClick(self, x, y, keys = 0, attachment = 0):
 613         shape = self.GetShape()
 614         if hasattr(shape, "GetModel"):  # Workaround, on drag, we should deselect all other objects and select the clicked on object
 615             model = shape.GetModel()
 616         else:
 617             shape = shape.GetParent()
 618             if shape:
 619                 model = shape.GetModel()
 620
 621         self._view.SetSelection(model, keys == self.SHIFT_KEY or keys == self.CONTROL_KEY)
 622         self._view.SetPropertyShape(shape)
 623         self._view.SetPropertyModel(model)
 624
 625
 626     def OnEndDragLeft(self, x, y, keys = 0, attachment = 0):
 627         ogl.ShapeEvtHandler.OnEndDragLeft(self, x, y, keys, attachment)
 628         shape = self.GetShape()
 629         if hasattr(shape, "GetModel"):  # Workaround, on drag, we should deselect all other objects and select the clicked on object
 630             model = shape.GetModel()
 631         else:
 632             parentShape = shape.GetParent()
 633             if parentShape:
 634                 model = parentShape.GetModel()
 635         self._view.SetSelection(model, keys == self.SHIFT_KEY or keys == self.CONTROL_KEY)
 636
 637
 638     def OnMovePost(self, dc, x, y, oldX, oldY, display):
 639         if x == oldX and y == oldY:
 640             return
 641         if not self._view.GetDocument():
 642             return
 643         shape = self.GetShape()
 644         if isinstance(shape, EditorCanvasShapeMixin) and shape.Draggable():
 645             model = shape.GetModel()
 646             if hasattr(model, "getEditorBounds") and model.getEditorBounds():
 647                 x, y, w, h = model.getEditorBounds()
 648                 newX = shape.GetX() - shape.GetBoundingBoxMax()[0] / 2
 649                 newY = shape.GetY() - shape.GetBoundingBoxMax()[1] / 2
 650                 newWidth = shape.GetBoundingBoxMax()[0]
 651                 newHeight = shape.GetBoundingBoxMax()[1]
 652                 if shape._shadowMode != ogl.SHADOW_NONE:
 653                     newWidth -= shape._shadowOffsetX
 654                     newHeight -= shape._shadowOffsetY
 655                 newbounds = (newX, newY, newWidth, newHeight)
 656
 657                 if x != newX or y != newY or w != newWidth or h != newHeight:
 658                     self._view.GetDocument().GetCommandProcessor().Submit(EditorCanvasUpdateShapeBoundariesCommand(self._view.GetDocument(), model, newbounds))
 659
 660
 661     def Draw(self, dc):
 662         pass
 663
 664
 665 class EditorCanvasUpdateShapeBoundariesCommand(wx.lib.docview.Command):
 666
 667
 668     def __init__(self, canvasDocument, model, newbounds):
 669         wx.lib.docview.Command.__init__(self, canUndo = True)
 670         self._canvasDocument = canvasDocument
 671         self._model = model
 672         self._oldbounds = model.getEditorBounds()
 673         self._newbounds = newbounds
 674
 675
 676     def GetName(self):
 677         name = self._canvasDocument.GetNameForObject(self._model)
 678         if not name:
 679             name = ""
 680             print "ERROR: AbstractEditor.EditorCanvasUpdateShapeBoundariesCommand.GetName: unable to get name for ", self._model
 681         return _("Move/Resize %s") % name
 682
 683
 684     def Do(self):
 685         return self._canvasDocument.UpdateEditorBoundaries(self._model, self._newbounds)
 686
 687
 688     def Undo(self):
 689         return self._canvasDocument.UpdateEditorBoundaries(self._model, self._oldbounds)
 690