#---------------------------------------------------------------------------- # Name: AbstractEditor.py # Purpose: Non-text editor for DataModel and Process # # Author: Peter Yared, Morgan Hua # # Created: 7/28/04 # CVS-ID: $Id$ # Copyright: (c) 2004-2005 ActiveGrid, Inc. # License: wxWindows License #---------------------------------------------------------------------------- import wx import wx.lib.docview import wx.lib.ogl as ogl import PropertyService _ = wx.GetTranslation SELECT_BRUSH = wx.Brush("BLUE", wx.SOLID) SHAPE_BRUSH = wx.Brush("WHEAT", wx.SOLID) LINE_BRUSH = wx.BLACK_BRUSH INACTIVE_SELECT_BRUSH = wx.Brush("LIGHT BLUE", wx.SOLID) NORMALFONT = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT) SLANTFONT = wx.Font(NORMALFONT.GetPointSize(), NORMALFONT.GetFamily(), wx.SLANT, NORMALFONT.GetWeight()) BOLDFONT = wx.Font(NORMALFONT.GetPointSize(), NORMALFONT.GetFamily(), NORMALFONT.GetStyle(), wx.BOLD) DEFAULT_BACKGROUND_COLOR = wx.Colour(0xEE, 0xEE, 0xEE) HEADER_BRUSH = wx.Brush(wx.Colour(0xDB, 0xEB, 0xFF), wx.SOLID) BODY_BRUSH = wx.Brush(wx.WHITE, wx.SOLID) PARKING_VERTICAL = 1 PARKING_HORIZONTAL = 2 PARKING_OFFSET = 30 # space between shapes FORCE_REDRAW_METHOD = "ForceRedraw" def GetRawModel(model): if hasattr(model, "GetRawModel"): rawModel = model.GetRawModel() else: rawModel = model return rawModel def GetLabel(model): model = GetRawModel(model) if hasattr(model, "__xmlname__"): label = model.__xmlname__ try: if (len(label) > 0): label = label[0].upper() + label[1:] if (hasattr(model, "complexType")): label += ': %s/%s' % (model.complexType.name, model.name) else: if model.name: label += ': %s' % model.name elif model.ref: label += ': %s' % model.ref except AttributeError: pass else: label = str(model) return label class CanvasView(wx.lib.docview.View): #---------------------------------------------------------------------------- # Overridden methods #---------------------------------------------------------------------------- def __init__(self, brush=SHAPE_BRUSH, background=DEFAULT_BACKGROUND_COLOR): wx.lib.docview.View.__init__(self) self._brush = brush self._backgroundColor = background self._canvas = None self._pt1 = None self._pt2 = None self._needEraseLasso = False self._propShape = None self._maxWidth = 2000 self._maxHeight = 16000 self._valetParking = False def OnDraw(self, dc): """ for Print Preview and Print """ dc.BeginDrawing() self._canvas.Redraw(dc) dc.EndDrawing() def OnCreate(self, doc, flags): frame = wx.GetApp().CreateDocumentFrame(self, doc, flags) frame.Show() sizer = wx.BoxSizer() self._CreateCanvas(frame) sizer.Add(self._canvas, 1, wx.EXPAND, 0) frame.SetSizer(sizer) frame.Layout() self.Activate() wx.EVT_RIGHT_DOWN(self._canvas, self.OnRightClick) return True def OnActivateView(self, activate, activeView, deactiveView): if activate and self._canvas: # In MDI mode just calling set focus doesn't work and in SDI mode using CallAfter causes an endless loop if self.GetDocumentManager().GetFlags() & wx.lib.docview.DOC_SDI: self.SetFocus() else: wx.CallAfter(self.SetFocus) def SetFocus(self): if self._canvas: self._canvas.SetFocus() def OnFocus(self, event): self.FocusColorPropertyShape(True) event.Skip() def FocusOnClick(self, event): self.SetFocus() event.Skip() def OnKillFocus(self, event): self.FocusColorPropertyShape(False) event.Skip() def HasFocus(self): winWithFocus = wx.Window.FindFocus() if not winWithFocus: return False while winWithFocus: if winWithFocus == self._canvas: return True winWithFocus = winWithFocus.GetParent() return False def OnClose(self, deleteWindow = True): statusC = wx.GetApp().CloseChildDocuments(self.GetDocument()) statusP = wx.lib.docview.View.OnClose(self, deleteWindow = deleteWindow) if hasattr(self, "ClearOutline"): wx.CallAfter(self.ClearOutline) # need CallAfter because when closing the document, it is Activated and then Close, so need to match OnActivateView's CallAfter if not (statusC and statusP): return False self.Activate(False) if deleteWindow and self.GetFrame(): self.GetFrame().Destroy() return True def _CreateCanvas(self, parent): self._canvas = ogl.ShapeCanvas(parent) wx.EVT_LEFT_DOWN(self._canvas, self.OnLeftClick) wx.EVT_LEFT_UP(self._canvas, self.OnLeftUp) wx.EVT_MOTION(self._canvas, self.OnLeftDrag) wx.EVT_LEFT_DCLICK(self._canvas, self.OnLeftDoubleClick) wx.EVT_KEY_DOWN(self._canvas, self.OnKeyPressed) # need this otherwise mouse clicks don't set focus to this view wx.EVT_LEFT_DOWN(self._canvas, self.FocusOnClick) wx.EVT_LEFT_DCLICK(self._canvas, self.FocusOnClick) wx.EVT_RIGHT_DOWN(self._canvas, self.FocusOnClick) wx.EVT_RIGHT_DCLICK(self._canvas, self.FocusOnClick) wx.EVT_MIDDLE_DOWN(self._canvas, self.FocusOnClick) wx.EVT_MIDDLE_DCLICK(self._canvas, self.FocusOnClick) wx.EVT_KILL_FOCUS(self._canvas, self.OnKillFocus) wx.EVT_SET_FOCUS(self._canvas, self.OnFocus) self._canvas.SetScrollbars(20, 20, self._maxWidth / 20, self._maxHeight / 20) self._canvas.SetBackgroundColour(self._backgroundColor) self._diagram = ogl.Diagram() self._canvas.SetDiagram(self._diagram) self._diagram.SetCanvas(self._canvas) self._canvas.SetFont(NORMALFONT) def OnClear(self, event): """ Deletion of selected objects from view. *Must Override* """ self.SetPropertyModel(None) def SetLastRightClick(self, x, y): self._lastRightClick = (x,y) def GetLastRightClick(self): if hasattr(self, "_lastRightClick"): return self._lastRightClick return (-1,-1) def OnKeyPressed(self, event): key = event.KeyCode() if key == wx.WXK_DELETE: self.OnClear(event) else: event.Skip() def OnRightClick(self, event): """ force selection underneath right click position. """ self.Activate() self._canvas.SetFocus() dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) x, y = event.GetLogicalPosition(dc) # this takes into account scrollbar offset self.SetLastRightClick(x, y) shape = self._canvas.FindShape(x, y)[0] model = None if not shape: self.SetSelection(None) self.SetPropertyShape(None) elif hasattr(shape, "GetModel"): self.BringToFront(shape) self.SetPropertyShape(shape) self.SetSelection(shape) shape.Select(True, dc) model = shape.GetModel() elif shape.GetParent() and isinstance(shape.GetParent(), ogl.CompositeShape): # ComplexTypeHeader for ComplexTypeShape self.BringToFront(shape) self.SetPropertyShape(shape.GetParent()) self.SetSelection(shape.GetParent()) shape.GetParent().Select(True, dc) model = shape.GetParent().GetModel() self.SetPropertyModel(model) return (shape, model) def OnLeftClick(self, event): self.Activate() self._canvas.SetFocus() self.EraseRubberBand() dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) # keep track of mouse down for group select self._pt1 = event.GetLogicalPosition(dc) # this takes into account scrollbar offset self._pt2 = None shape = self._canvas.FindShape(self._pt1[0], self._pt1[1])[0] if shape: self.BringToFront(shape) self._pt1 = None event.Skip() # pass on event to shape handler to take care of selection return elif event.ControlDown() or event.ShiftDown(): # extend select, don't deselect pass else: # click on empty part of canvas, deselect everything forceRedrawShapes = [] needRefresh = False for shape in self._diagram.GetShapeList(): if hasattr(shape, "GetModel"): if shape.Selected(): needRefresh = True shape.Select(False, dc) if hasattr(shape, FORCE_REDRAW_METHOD): forceRedrawShapes.append(shape) if needRefresh: self._canvas.Redraw(dc) self.SetPropertyModel(None) if len(self.GetSelection()) == 0: self.SetPropertyShape(None) for shape in forceRedrawShapes: shape.ForceRedraw() def OnLeftDoubleClick(self, event): propertyService = wx.GetApp().GetService(PropertyService.PropertyService) if propertyService: propertyService.ShowWindow() def OnLeftDrag(self, event): # draw lasso for group select if self._pt1 and event.LeftIsDown(): # we are in middle of lasso selection self.EraseRubberBand() dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) self._pt2 = event.GetLogicalPosition(dc) # this takes into account scrollbar offset self.DrawRubberBand() else: event.Skip() def OnLeftUp(self, event): # do group select if self._needEraseLasso: self.EraseRubberBand() dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) x1, y1 = self._pt1 x2, y2 = event.GetLogicalPosition(dc) # this takes into account scrollbar offset tol = self._diagram.GetMouseTolerance() if abs(x1 - x2) > tol or abs(y1 - y2) > tol: # make sure x1 < x2 and y1 < y2 to make comparison test easier if x1 > x2: temp = x1 x1 = x2 x2 = temp if y1 > y2: temp = y1 y1 = y2 y2 = temp for shape in self._diagram.GetShapeList(): if not shape.GetParent() and hasattr(shape, "GetModel"): # if part of a composite, don't select it x, y = shape.GetX(), shape.GetY() width, height = shape.GetBoundingBoxMax() selected = x1 < x - width/2 and x2 > x + width/2 and y1 < y - height/2 and y2 > y + height/2 if event.ControlDown() or event.ShiftDown(): # extend select, don't deselect if selected: shape.Select(selected, dc) else: # select items in lasso and deselect items out of lasso shape.Select(selected, dc) self._canvas.Redraw(dc) else: event.Skip() else: event.Skip() def EraseRubberBand(self): if self._needEraseLasso: self._needEraseLasso = False dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) dc.SetLogicalFunction(wx.XOR) pen = wx.Pen(wx.Colour(200, 200, 200), 1, wx.SHORT_DASH) dc.SetPen(pen) brush = wx.Brush(wx.Colour(255, 255, 255), wx.TRANSPARENT) dc.SetBrush(brush) dc.ResetBoundingBox() dc.BeginDrawing() x1, y1 = self._pt1 x2, y2 = self._pt2 # make sure x1 < x2 and y1 < y2 # this will make (x1, y1) = upper left corner if x1 > x2: temp = x1 x1 = x2 x2 = temp if y1 > y2: temp = y1 y1 = y2 y2 = temp # erase previous outline dc.SetClippingRegion(x1, y1, x2 - x1, y2 - y1) dc.DrawRectangle(x1, y1, x2 - x1, y2 - y1) dc.EndDrawing() def DrawRubberBand(self): self._needEraseLasso = True dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) dc.SetLogicalFunction(wx.XOR) pen = wx.Pen(wx.Colour(200, 200, 200), 1, wx.SHORT_DASH) dc.SetPen(pen) brush = wx.Brush(wx.Colour(255, 255, 255), wx.TRANSPARENT) dc.SetBrush(brush) dc.ResetBoundingBox() dc.BeginDrawing() x1, y1 = self._pt1 x2, y2 = self._pt2 # make sure x1 < x2 and y1 < y2 # this will make (x1, y1) = upper left corner if x1 > x2: temp = x1 x1 = x2 x2 = temp if y1 > y2: temp = y1 y1 = y2 y2 = temp # draw outline dc.SetClippingRegion(x1, y1, x2 - x1, y2 - y1) dc.DrawRectangle(x1, y1, x2 - x1, y2 - y1) dc.EndDrawing() def SetValetParking(self, enable=True): """ If valet parking is enabled, remember last parking spot and try for a spot near it """ self._valetParking = enable if enable: self._valetPosition = None def FindParkingSpot(self, width, height, parking=PARKING_HORIZONTAL, x=PARKING_OFFSET, y=PARKING_OFFSET): """ Given a width and height, find a upper left corner where shape can be parked without overlapping other shape """ if self._valetParking and self._valetPosition: x, y = self._valetPosition max = 700 # max distance to the right where we'll place tables noParkingSpot = True while noParkingSpot: point = self.isSpotOccupied(x, y, width, height) if point: if parking == PARKING_HORIZONTAL: x = point[0] + PARKING_OFFSET if x > max: x = PARKING_OFFSET y = point[1] + PARKING_OFFSET else: # parking == PARKING_VERTICAL: y = point[1] + PARKING_OFFSET if y > max: y = PARKING_OFFSET x = point[0] + PARKING_OFFSET else: noParkingSpot = False if self._valetParking: self._valetPosition = (x, y) return x, y def isSpotOccupied(self, x, y, width, height): """ returns None if at x,y,width,height no object occupies that rectangle, otherwise returns lower right corner of object that occupies given x,y position """ x2 = x + width y2 = y + height for shape in self._diagram.GetShapeList(): if isinstance(shape, ogl.RectangleShape) or isinstance(shape, ogl.EllipseShape) or isinstance(shape, ogl.PolygonShape): if shape.GetParent() and isinstance(shape.GetParent(), ogl.CompositeShape): # skip, part of a composite shape continue if hasattr(shape, "GetModel"): other_x, other_y, other_width, other_height = shape.GetModel().getEditorBounds() other_x2 = other_x + other_width other_y2 = other_y + other_height else: # shapes x,y are at the center of the shape, need to transform to upper left coordinate other_width, other_height = shape.GetBoundingBoxMax() other_x = shape.GetX() - other_width/2 other_y = shape.GetY() - other_height/2 other_x2 = other_x + other_width other_y2 = other_y + other_height # intersection check if ((other_x2 < other_x or other_x2 > x) and (other_y2 < other_y or other_y2 > y) and (x2 < x or x2 > other_x) and (y2 < y or y2 > other_y)): return (other_x2, other_y2) return None #---------------------------------------------------------------------------- # Canvas methods #---------------------------------------------------------------------------- def AddShape(self, shape, x = None, y = None, pen = None, brush = None, text = None, eventHandler = None, shown=True): if isinstance(shape, ogl.CompositeShape): dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) shape.Move(dc, x, y) else: shape.SetDraggable(True, True) shape.SetCanvas(self._canvas) if x: shape.SetX(x) if y: shape.SetY(y) shape.SetCentreResize(False) if pen: shape.SetPen(pen) if brush: shape.SetBrush(brush) if text: shape.AddText(text) shape.SetShadowMode(ogl.SHADOW_NONE) self._diagram.AddShape(shape) shape.Show(shown) if not eventHandler: eventHandler = EditorCanvasShapeEvtHandler(self) eventHandler.SetShape(shape) eventHandler.SetPreviousHandler(shape.GetEventHandler()) shape.SetEventHandler(eventHandler) return shape def RemoveShape(self, model = None, shape = None): if not model and not shape: return if not shape: shape = self.GetShape(model) if shape: shape.Select(False) for line in shape.GetLines(): shape.RemoveLine(line) self._diagram.RemoveShape(line) line.Delete() for obj in self._diagram.GetShapeList(): for line in obj.GetLines(): if self.IsShapeContained(shape, line.GetTo()) or self.IsShapeContained(shape, line.GetFrom()): obj.RemoveLine(line) self._diagram.RemoveShape(line) line.Delete() if line == shape: obj.RemoveLine(line) self._diagram.RemoveShape(line) line.Delete() if self._canvas: shape.RemoveFromCanvas(self._canvas) self._diagram.RemoveShape(shape) shape.Delete() def IsShapeContained(self, parent, shape): if parent == shape: return True elif shape.GetParent(): return self.IsShapeContained(parent, shape.GetParent()) return False def UpdateShape(self, model): for shape in self._diagram.GetShapeList(): if hasattr(shape, "GetModel") and shape.GetModel() == model: oldw, oldh = shape.GetBoundingBoxMax() oldx = shape.GetX() oldy = shape.GetY() x, y, w, h = model.getEditorBounds() newX = x + w / 2 newY = y + h / 2 if oldw != w or oldh != h or oldx != newX or oldy != newY: dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) shape.SetSize(w, h, True) # wxBug: SetSize must be before Move because links won't go to the right place shape.Move(dc, newX, newY) # wxBug: Move must be after SetSize because links won't go to the right place shape.ResetControlPoints() self._canvas.Refresh() break def GetShape(self, model): for shape in self._diagram.GetShapeList(): if hasattr(shape, "GetModel") and shape.GetModel() == model: return shape return None def GetShapeCount(self): return self._diagram.GetCount() def GetSelection(self): return filter(lambda shape: shape.Selected(), self._diagram.GetShapeList()) def SetSelection(self, models, extendSelect = False): dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) update = False if not isinstance(models, type([])) and not isinstance(models, type(())): models = [models] for shape in self._diagram.GetShapeList(): if hasattr(shape, "GetModel"): if shape.Selected() and not shape.GetModel() in models: # was selected, but not in new list, so deselect, unless extend select if not extendSelect: shape.Select(False, dc) update = True elif not shape.Selected() and shape.GetModel() in models: # was not selected and in new list, so select shape.Select(True, dc) update = True elif extendSelect and shape.Selected() and shape.GetModel() in models: # was selected, but extend select means to deselect shape.Select(False, dc) update = True if update: self._canvas.Redraw(dc) def BringToFront(self, shape): if shape.GetParent() and isinstance(shape.GetParent(), ogl.CompositeShape): self._diagram.RemoveShape(shape.GetParent()) self._diagram.AddShape(shape.GetParent()) else: self._diagram.RemoveShape(shape) self._diagram.AddShape(shape) def SendToBack(self, shape): if shape.GetParent() and isinstance(shape.GetParent(), ogl.CompositeShape): self._diagram.RemoveShape(shape.GetParent()) self._diagram.InsertShape(shape.GetParent()) else: self._diagram.RemoveShape(shape) self._diagram.InsertShape(shape) def ScrollVisible(self, shape): if not shape: return xUnit, yUnit = self._canvas.GetScrollPixelsPerUnit() scrollX, scrollY = self._canvas.GetViewStart() # in scroll units scrollW, scrollH = self._canvas.GetSize() # in pixels w, h = shape.GetBoundingBoxMax() # in pixels x = shape.GetX() - w/2 # convert to upper left coordinate from center y = shape.GetY() - h/2 # convert to upper left coordinate from center if x >= scrollX*xUnit and x <= scrollX*xUnit + scrollW: # don't scroll if already visible x = -1 else: x = x/xUnit if y >= scrollY*yUnit and y <= scrollY*yUnit + scrollH: # don't scroll if already visible y = -1 else: y = y/yUnit self._canvas.Scroll(x, y) # in scroll units def SetPropertyShape(self, shape): # no need to highlight if no PropertyService is running propertyService = wx.GetApp().GetService(PropertyService.PropertyService) if not propertyService: return if shape == self._propShape: return if hasattr(shape, "GetPropertyShape"): shape = shape.GetPropertyShape() dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) dc.BeginDrawing() # erase old selection if it still exists if self._propShape and self._propShape in self._diagram.GetShapeList(): if hasattr(self._propShape, "DEFAULT_BRUSH"): self._propShape.SetBrush(self._propShape.DEFAULT_BRUSH) else: self._propShape.SetBrush(self._brush) if (self._propShape._textColourName in ["BLACK", "WHITE"]): # Would use GetTextColour() but it is broken self._propShape.SetTextColour("BLACK", 0) self._propShape.Draw(dc) # set new selection self._propShape = shape # draw new selection if self._propShape and self._propShape in self._diagram.GetShapeList(): if self.HasFocus(): self._propShape.SetBrush(SELECT_BRUSH) else: self._propShape.SetBrush(INACTIVE_SELECT_BRUSH) if (self._propShape._textColourName in ["BLACK", "WHITE"]): # Would use GetTextColour() but it is broken self._propShape.SetTextColour("WHITE", 0) self._propShape.Draw(dc) dc.EndDrawing() def FocusColorPropertyShape(self, gotFocus=False): # no need to change highlight if no PropertyService is running propertyService = wx.GetApp().GetService(PropertyService.PropertyService) if not propertyService: return if not self._propShape: return dc = wx.ClientDC(self._canvas) self._canvas.PrepareDC(dc) dc.BeginDrawing() # draw deactivated selection if self._propShape and self._propShape in self._diagram.GetShapeList(): if gotFocus: self._propShape.SetBrush(SELECT_BRUSH) else: self._propShape.SetBrush(INACTIVE_SELECT_BRUSH) if (self._propShape._textColourName in ["BLACK", "WHITE"]): # Would use GetTextColour() but it is broken self._propShape.SetTextColour("WHITE", 0) self._propShape.Draw(dc) if hasattr(self._propShape, FORCE_REDRAW_METHOD): self._propShape.ForceRedraw() dc.EndDrawing() #---------------------------------------------------------------------------- # Property Service methods #---------------------------------------------------------------------------- def GetPropertyModel(self): if hasattr(self, "_propModel"): return self._propModel return None def SetPropertyModel(self, model): # no need to set the model if no PropertyService is running propertyService = wx.GetApp().GetService(PropertyService.PropertyService) if not propertyService: return if hasattr(self, "_propModel") and model == self._propModel: return self._propModel = model propertyService.LoadProperties(self._propModel, self.GetDocument()) class EditorCanvasShapeMixin: def GetModel(self): return self._model def SetModel(self, model): self._model = model class EditorCanvasShapeEvtHandler(ogl.ShapeEvtHandler): """ wxBug: Bug in OLG package. With wxShape.SetShadowMode() turned on, when we set the size, the width/height is larger by 6 pixels. Need to subtract this value from width and height when we resize the object. """ SHIFT_KEY = 1 CONTROL_KEY = 2 def __init__(self, view): ogl.ShapeEvtHandler.__init__(self) self._view = view def OnLeftClick(self, x, y, keys = 0, attachment = 0): shape = self.GetShape() if hasattr(shape, "GetModel"): # Workaround, on drag, we should deselect all other objects and select the clicked on object model = shape.GetModel() else: shape = shape.GetParent() if shape: model = shape.GetModel() if model: self._view.SetSelection(model, keys == self.SHIFT_KEY or keys == self.CONTROL_KEY) self._view.SetPropertyShape(shape) self._view.SetPropertyModel(model) def OnEndDragLeft(self, x, y, keys = 0, attachment = 0): ogl.ShapeEvtHandler.OnEndDragLeft(self, x, y, keys, attachment) shape = self.GetShape() if hasattr(shape, "GetModel"): # Workaround, on drag, we should deselect all other objects and select the clicked on object model = shape.GetModel() else: parentShape = shape.GetParent() if parentShape: model = parentShape.GetModel() self._view.SetSelection(model, keys == self.SHIFT_KEY or keys == self.CONTROL_KEY) def OnMovePre(self, dc, x, y, oldX, oldY, display): """ Prevent objects from being dragged outside of viewable area """ if (x < 0) or (y < 0) or (x > self._view._maxWidth) or (y > self._view._maxHeight): return False return ogl.ShapeEvtHandler.OnMovePre(self, dc, x, y, oldX, oldY, display) def OnMovePost(self, dc, x, y, oldX, oldY, display): """ Update the model's record of where the shape should be. Also enable redo/undo. """ if x == oldX and y == oldY: return if not self._view.GetDocument(): return shape = self.GetShape() if isinstance(shape, EditorCanvasShapeMixin) and shape.Draggable(): model = shape.GetModel() if hasattr(model, "getEditorBounds") and model.getEditorBounds(): x, y, w, h = model.getEditorBounds() newX = shape.GetX() - shape.GetBoundingBoxMax()[0] / 2 newY = shape.GetY() - shape.GetBoundingBoxMax()[1] / 2 newWidth = shape.GetBoundingBoxMax()[0] newHeight = shape.GetBoundingBoxMax()[1] if shape._shadowMode != ogl.SHADOW_NONE: newWidth -= shape._shadowOffsetX newHeight -= shape._shadowOffsetY newbounds = (newX, newY, newWidth, newHeight) if x != newX or y != newY or w != newWidth or h != newHeight: self._view.GetDocument().GetCommandProcessor().Submit(EditorCanvasUpdateShapeBoundariesCommand(self._view.GetDocument(), model, newbounds)) def Draw(self, dc): pass class EditorCanvasUpdateShapeBoundariesCommand(wx.lib.docview.Command): def __init__(self, canvasDocument, model, newbounds): wx.lib.docview.Command.__init__(self, canUndo = True) self._canvasDocument = canvasDocument self._model = model self._oldbounds = model.getEditorBounds() self._newbounds = newbounds def GetName(self): name = self._canvasDocument.GetNameForObject(self._model) if not name: name = "" print "ERROR: AbstractEditor.EditorCanvasUpdateShapeBoundariesCommand.GetName: unable to get name for ", self._model return _("Move/Resize %s") % name def Do(self): return self._canvasDocument.UpdateEditorBoundaries(self._model, self._newbounds) def Undo(self): return self._canvasDocument.UpdateEditorBoundaries(self._model, self._oldbounds)