abstracteditor.py

Wxpython Implemented on Windows CE, Source code

#----------------------------------------------------------------------------
# Name:         AbstractEditor.py
# Purpose:      Non-text editor for DataModel and Process
#
# Author:       Peter Yared, Morgan Hua
#
# Created:      7/28/04
# CVS-ID:       $Id: AbstractEditor.py,v 1.7 2006/04/20 06:26:01 RD Exp $
# 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)