/Users/maurits/Documents/studie/afstuderen/biosphere/python/biosphere/gui_complex.py

Go to the documentation of this file.

import wx


class InputOutputShape:
    def __init__(self, parent, type='input', pos=(100, 100)):
        self.parentparent = parent
        self.typetype = type
        self.pospos = pos
        self.shownshown = True
        self.fullscreenfullscreen = False
        
        self.namename = type
        self.bmpbmp = wx.Bitmap('bitmaps/%s.png' % self.typetype[:-3])
        self.namebmpnamebmp = self.GetNameBitmapGetNameBitmap()
        
        # this will be the type this shape is connected to
        self.connectedToconnectedTo = None
    
    def Draw(self, dc, op = wx.COPY):
        if self.bmpbmp.Ok() and self.namebmpnamebmp.Ok():
            memDC = wx.MemoryDC()
            
            # draw name:
            memDC.SelectObject(self.namebmpnamebmp)
            if self.typetype == 'input':
                dc.Blit(self.pospos[0] + self.bmpbmp.GetWidth()/2 - self.namebmpnamebmp.GetWidth()/2 - 10, 
                        self.pospos[1] - self.namebmpnamebmp.GetHeight(), 
                        self.namebmpnamebmp.GetWidth(), self.namebmpnamebmp.GetHeight(), 
                        memDC, 0, 0, op, True)
            else:
                dc.Blit(self.pospos[0] + self.bmpbmp.GetWidth()/2 - self.namebmpnamebmp.GetWidth()/2 + 10, 
                    self.pospos[1] - self.namebmpnamebmp.GetHeight(), 
                    self.namebmpnamebmp.GetWidth(), self.namebmpnamebmp.GetHeight(), 
                    memDC, 0, 0, op, True)
            
            # draw image:
            memDC.SelectObject(self.bmpbmp)
            dc.Blit(self.pospos[0], self.pospos[1], 
                    self.bmpbmp.GetWidth(), self.bmpbmp.GetHeight(), 
                    memDC, 0, 0, op, True)
    
    def GetNameBitmap(self):
        font = wx.Font(11, wx.MODERN, wx.NORMAL, wx.NORMAL)
        textExtent = self.parentparent.GetFullTextExtent(self.namename, font)
        txtbmp = wx.EmptyBitmap(textExtent[0], textExtent[1])
        
        memDC = wx.MemoryDC()
        memDC.SelectObject(txtbmp)
        memDC.SetBackground(wx.Brush(wx.WHITE, wx.SOLID))
        memDC.Clear()
        memDC.SetTextForeground(wx.BLACK)
        memDC.SetFont(font)
        memDC.DrawText(self.namename, 0, 0)
        
        mask = wx.Mask(txtbmp, wx.WHITE)
        txtbmp.SetMask(mask)
        return txtbmp
    
    def Rename(self, name):
        self.namename = name
        self.namebmpnamebmp = self.GetNameBitmapGetNameBitmap()
    
    def HitTestBody(self, pt):
        rect = self.GetRectGetRect()
        if self.typetype == 'input':
            rect.width = rect.width - 20
        else:
            rect.x = rect.x + 20
            rect.width = rect.width - 20
        
        return rect.InsideXY(pt.x, pt.y)
    
    def HitTestArrow(self, pt):
        # TODO this can be much more efficiently!
        rect = self.GetRectGetRect()
        return rect.InsideXY(pt.x, pt.y) and not self.HitTestBodyHitTestBody(pt)
    
    def GetRect(self):
        return wx.Rect(self.pospos[0], self.pospos[1], 
                      self.bmpbmp.GetWidth(), self.bmpbmp.GetHeight())
    

class DragShape:
    def __init__(self, parent, operation, name, pos=(100, 100)):
        # logical attributes:
        self.parentparent = parent
        self.operationoperation = operation
        
        # graphical attributes:
        self.namename = name
        self.bmpbmp = self.GetBitmapGetBitmap()
        self.namebmpnamebmp = self.GetNameBitmapGetNameBitmap()
        self.pospos = pos
        self.shownshown = True
        self.fullscreenfullscreen = False
        
    def Rename(self, name):
        self.namename = name
        self.namebmpnamebmp = self.GetNameBitmapGetNameBitmap()
    
    def GetBitmap(self):
        self.num_innum_in  = len(self.operationoperation.input.parts)
        self.num_outnum_out = len(self.operationoperation.output.parts)
        return wx.Bitmap('bitmaps/%dto%d.png' % (self.num_innum_in, self.num_outnum_out))
    
    def GetNameBitmap(self):
        font = wx.Font(11, wx.MODERN, wx.NORMAL, wx.NORMAL)
        textExtent = self.parentparent.GetFullTextExtent(self.namename, font)
        txtbmp = wx.EmptyBitmap(textExtent[0], textExtent[1])
        
        memDC = wx.MemoryDC()
        memDC.SelectObject(txtbmp)
        memDC.SetBackground(wx.Brush(wx.WHITE, wx.SOLID))
        memDC.Clear()
        memDC.SetTextForeground(wx.BLACK)
        memDC.SetFont(font)
        memDC.DrawText(self.namename, 0, 0)
        
        mask = wx.Mask(txtbmp, wx.WHITE)
        txtbmp.SetMask(mask)
        return txtbmp

    def HitTestBody(self, pt):
        rect = self.GetRectGetRect()
        if self.num_innum_in > 0:
            rect.x = rect.x + 27
            rect.width = rect.width - 27
        if self.num_outnum_out > 0:
            rect.width = rect.width - 27
        
        return rect.InsideXY(pt.x, pt.y)
    
    def HitTestArrow(self, pt):
        # TODO this can be much more efficiently!
        rect = self.GetRectGetRect()
        return rect.InsideXY(pt.x, pt.y) and not self.HitTestBodyHitTestBody(pt)

    def GetRect(self):
        return wx.Rect(self.pospos[0], self.pospos[1], 
                      self.bmpbmp.GetWidth(), self.bmpbmp.GetHeight())

    def Draw(self, dc, op = wx.COPY):
        if self.bmpbmp.Ok() and self.namebmpnamebmp.Ok():
            memDC = wx.MemoryDC()
            
            # draw name:
            memDC.SelectObject(self.namebmpnamebmp)
            dc.Blit(self.pospos[0] + self.bmpbmp.GetWidth()/2 - self.namebmpnamebmp.GetWidth()/2, 
                    self.pospos[1] - self.namebmpnamebmp.GetHeight(), 
                    self.namebmpnamebmp.GetWidth(), self.namebmpnamebmp.GetHeight(), 
                    memDC, 0, 0, op, True)
            
            # draw image:
            memDC.SelectObject(self.bmpbmp)
            dc.Blit(self.pospos[0], self.pospos[1], 
                    self.bmpbmp.GetWidth(), self.bmpbmp.GetHeight(), 
                    memDC, 0, 0, op, True)


class Connection:
    def __init__(self, parent, input, output):
        # lookup table for connection endpoints:
        self.coordictcoordict = {'in.png': ([], [20]),
                         'out.png': ([20], []),
                    '0to1.png': ([], [31]),
                    '0to2.png': ([], [18, 43]),
                    '0to3.png': ([], [18, 43, 67]),
                    '0to4.png': ([], [18, 43, 67, 93]),
                    '0to5.png': ([], [18, 43, 67, 93, 118]),
                    '1to0.png': ([31], []),
                    '1to1.png': ([31], [31]),
                    '1to2.png': ([31], [18, 43]),
                    '1to3.png': ([43], [18, 43, 67]),
                    '1to4.png': ([56], [18, 43, 67, 93]),
                    '1to5.png': ([68], [18, 43, 67, 93, 118]),
                    '2to0.png': ([18, 43], []),
                    '2to1.png': ([18, 43], [31]),
                    '2to2.png': ([18, 43], [18, 43]),
                    '2to3.png': ([30, 56], [18, 43, 67]),
                    '2to4.png': ([43, 67], [18, 43, 67, 93]),
                    '2to5.png': ([43, 93], [18, 43, 67, 93, 118]),
                    '3to0.png': ([18, 43, 67], []),
                    '3to1.png': ([18, 43, 67], [43]),
                    '3to2.png': ([18, 43, 67], [30, 56]),
                    '3to3.png': ([18, 43, 67], [18, 43, 67]),
                    '3to4.png': ([30, 55, 80], [18, 43, 67, 93]),
                    '3to5.png': ([43, 67, 93], [18, 43, 67, 93, 118]),
                    '4to0.png': ([18, 43, 67, 93], []),
                    '4to1.png': ([18, 43, 67, 93], [55]),
                    '4to2.png': ([18, 43, 67, 93], [43, 67]),
                    '4to3.png': ([18, 43, 67, 93], [30, 55, 80]),
                    '4to4.png': ([18, 43, 67, 93], [18, 43, 67, 93]),
                    '4to5.png': ([31, 56, 81, 106], [18, 43, 67, 93, 118]),
                    '5to0.png': ([18, 43, 67, 93, 118], []),
                    '5to1.png': ([18, 43, 67, 93, 118], [67]),
                    '5to2.png': ([18, 43, 67, 93, 118], [43, 93]),
                    '5to3.png': ([18, 43, 67, 93, 118], [43, 67, 93]),
                    '5to4.png': ([18, 43, 67, 93, 118], [31, 56, 81, 106]),
                    '5to5.png': ([18, 43, 67, 93, 118], [18, 43, 67, 93, 118])
                    }
        
        self.parentparent = parent
        self.outputoutput = output # tuple (shape, op#)
        self.inputinput = input
        self.iposipos = None
        self.oposopos = None
        self.shownshown = True
        
        self.ibmpnameibmpname = '%dto%d.png' % (len(self.inputinput[0].operation.input.parts),
                                        len(self.inputinput[0].operation.output.parts))
        self.obmpnameobmpname = '%dto%d.png' % (len(self.outputoutput[0].operation.input.parts),
                                        len(self.outputoutput[0].operation.output.parts))
        
        self.CalculateCoordsCalculateCoords()
    
    def CalculateCoords(self):
        self.iposipos = self.GetCoordsForShapeGetCoordsForShape(self.inputinput[0], self.inputinput[1])
        self.oposopos = self.GetCoordsForShapeGetCoordsForShape(self.outputoutput[0],
                                           self.outputoutput[1], False)
    
    def GetCoordsForShape(self, shape, partno, input=True):
        if input:
            bmfname = self.ibmpnameibmpname
            if bmfname not in self.coordictcoordict:
                return None
            else:
                return (shape.pos[0] + 2,
                        shape.pos[1] + self.coordictcoordict[bmfname][0][partno])
        else:
            bmfname = self.obmpnameobmpname
            if bmfname not in self.coordictcoordict:
                return None
            else:
                return (shape.pos[0] - 2 + shape.bmp.GetWidth(),
                        shape.pos[1] + self.coordictcoordict[bmfname][1][partno])
    
    def Draw(self, dc):
        if self.iposipos and self.oposopos:
            dc.SetPen(wx.Pen('black', 2))
            dc.DrawLine(self.iposipos[0], self.iposipos[1],
                        self.oposopos[0], self.oposopos[1])
    
    def HitTest(self, pt):
        if not self.shownshown or not self.iposipos or not self.oposopos:
            return False
        
        # look if point is in square box:
        d = 8
        if pt.x < ipos[0]-d and pt.x < opos[0]-d or pt.x > ipos[0]+d and pt.x > opos[0]+d:
            return False
        if pt.x < ipos[1]-d and pt.x < opos[1]-d or pt.x > ipos[1]+d and pt.x > opos[1]+d:
            return False
        
        # calculate
        rc = float((d - b) / (c - a))
        if rc > 1.0 or rc < -1.0:
            # use y = f(x)
            pass
        else:
            # use x = f-1(y)
            pass

class DragCanvas(wx.Panel):
    def __init__(self, parent, ID, definition = None):
        wx.Panel.__init__(self, parent, ID)
        self.defsdefs = definition
        
        # attributes for shape drawing and dragging:
        self.shapesshapes = []
        self.dragImagedragImage = None
        self.dragShapedragShape = None
        
        # attributes for arrow connecting:
        self.dragArrowdragArrow = None
        self.dragFirstdragFirst = None
        self.connectionsconnections = []
        self.selectedShapeselectedShape = None

        self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
        self.bg_bmpbg_bmp = wx.Bitmap('bitmaps/background.bmp')
        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
        self.SetBackgroundColour(wx.WHITE)

        self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackgroundOnEraseBackground)
        self.Bind(wx.EVT_PAINT, self.OnPaintOnPaint)
        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDownOnLeftDown)
        self.Bind(wx.EVT_LEFT_UP, self.OnLeftUpOnLeftUp)
        self.Bind(wx.EVT_MOTION, self.OnMotionOnMotion)
        self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightMouseDownOnRightMouseDown)
    
    def AddOperation(self, operation):
        shape_count = 1
        for s in self.shapesshapes:
            if s.operation.name == operation.name:
                shape_count += 1
        if shape_count == 1:
            shape = DragShape(self, operation, operation.name)
        else:
            shape = DragShape(self, operation, 
                              '%s<%d>' % (operation.name, shape_count))
        self.shapesshapes.append(shape)
        self.Refresh()
    
    def AddInput(self):
        s = InputOutputShape(self)
        self.shapesshapes.append(s)
        self.Refresh()
    
    def AddOutput(self):
        s = InputOutputShape(self, type="output")
        self.shapesshapes.append(s)
        self.Refresh()
    
    def SetDefs(self, definition):
        # new definitions are set, so clear everything:
        self.defsdefs = definition
        self.ClearAllClearAll()
    
    def ClearAll(self):
        self.dragImagedragImage = None
        self.dragShapedragShape = None
        dc = wx.ClientDC(self)
        
        self.shapesshapes = []
        self.connectionsconnections = []
        self.TileBackgroundTileBackground(dc)

    # tile the background bitmap
    def TileBackground(self, dc):
        sz = self.GetClientSize()
        w = self.bg_bmpbg_bmp.GetWidth()
        h = self.bg_bmpbg_bmp.GetHeight()

        x = 0
        while x < sz.width:
            y = 0
            while y < sz.height:
                dc.DrawBitmap(self.bg_bmpbg_bmp, x, y)
                y += h
            x += w

    def DrawShapes(self, dc):
        for shape in self.shapesshapes:
            if shape.shown:
                shape.Draw(dc)
        for connection in self.connectionsconnections:
            if connection.shown:
                connection.Draw(dc)
    
    # This is actually a sophisticated 'hit test', but in this
    # case we're also determining which shape, if any, was 'hit'.
    def FindShapeBody(self, pt):
        for s in reversed(self.shapesshapes):
            if s.HitTestBody(pt):
                return s
        return None
    
    def FindShapeArrow(self, pt):
        # returns the shape whose arrows were clicked:
        for s in reversed(self.shapesshapes):
            if s.HitTestArrow(pt):
                return s
        return None

    def EraseShape(self, shape, dc):
        # Remove a shape from the display
        r = shape.GetRect()
        dc.SetClippingRect(r)
        self.TileBackgroundTileBackground(dc)
        self.DrawShapesDrawShapes(dc)
        dc.DestroyClippingRegion()

    # Clears the background, then redraws it. If the DC is passed, then
    # we only do so in the area so designated. Otherwise, it's the whole thing.
    def OnEraseBackground(self, evt):
        dc = evt.GetDC()

        if not dc:
            dc = wx.ClientDC(self)
            rect = self.GetUpdateRegion().GetBox()
            dc.SetClippingRect(rect)
        self.TileBackgroundTileBackground(dc)

    # Fired whenever a paint event occurs
    def OnPaint(self, evt):
        dc = wx.PaintDC(self)
        self.PrepareDC(dc)
        self.DrawShapesDrawShapes(dc)

    def OnRightMouseDown(self, event):
        shape = self.FindShapeBodyFindShapeBody(event.GetPosition())
        if shape:
            self.ClearArrowDraggingClearArrowDragging()
            self.ClearShapeDraggingClearShapeDragging()
            self.selectedShapeselectedShape = shape
            
            menu = self.MakeArrowMenuMakeArrowMenu(shape)
            self.PopupMenu(menu)
            menu.Destroy()
            
            self.selectedShapeselectedShape = None
        else:
            self.ClearArrowDraggingClearArrowDragging()
            self.ClearShapeDraggingClearShapeDragging()

    def ClearArrowDragging(self):
        self.dragArrowdragArrow = None
        self.dragFirstdragFirst = None
        self.selectedShapeselectedShape = None
    
    def ClearShapeDragging(self):
        self.dragShapedragShape = None
        self.dragImagedragImage = None
        self.selectedShapeselectedShape = None
    
    def HandleArrow(self, arrow):
        # start connecting shapes
        if not self.dragArrowdragArrow:
            # this is the first endpoint of a connection
            self.ClearArrowDraggingClearArrowDragging()
            self.ClearShapeDraggingClearShapeDragging()
            self.dragArrowdragArrow = arrow
            self.selectedShapeselectedShape = arrow

            menu = self.MakeArrowMenuMakeArrowMenu(arrow)
            self.PopupMenu(menu)
            menu.Destroy()
                
            if self.dragFirstdragFirst:
                self.dragArrowdragArrow = arrow # only set permanently if part is selected
            else:
                self.dragArrowdragArrow = None
            self.selectedShapeselectedShape = None
        else:
            if arrow and arrow != self.dragArrowdragArrow:
                # the user clicked on the second arrow:
                self.dragArrowdragArrow = arrow
                self.dragImagedragImage = None
                self.dragShapedragShape = None
                self.selectedShapeselectedShape = arrow

                menu = self.MakeArrowMenuMakeArrowMenu(arrow)
                self.PopupMenu(menu)
                menu.Destroy()
                
                self.selectedShapeselectedShape = None
    
    # Left mouse button is down.
    def OnLeftDown(self, evt):
        # Did the mouse go down on one of our shapes?
        shape = self.FindShapeBodyFindShapeBody(evt.GetPosition())

        if shape and not self.dragArrowdragArrow:
            # we found a shape and we're not connecting, so we start dragging:
            self.ClearArrowDraggingClearArrowDragging()
            self.ClearShapeDraggingClearShapeDragging()
            
            self.dragShapedragShape = shape
            self.dragStartPos = evt.GetPosition()
        else:
            # we're not dragging
            if shape:
                # there is a shape and an arrow already set: connect!
                self.HandleArrowHandleArrow(shape)
                return
            
            # maybe the user clicked on an arrow?
            arrow = self.FindShapeArrowFindShapeArrow(evt.GetPosition())
            if arrow:
                self.HandleArrowHandleArrow(arrow)
            else:
                # User clicked nowhere:
                self.ClearArrowDraggingClearArrowDragging()
                self.ClearShapeDraggingClearShapeDragging()
    
    def MakeArrowMenu(self, arrow):
        """Create the menu which is displayed when the user clicks
        on an in- or output arrow.
        """
        input_ids = 3000
        output_ids = 4000
        
        menu = wx.Menu()
        m = menu.Append(-1, 'Connect %s' % arrow.name)
        m.Enable(False)
        menu.AppendSeparator()
        
        if isinstance(arrow, DragShape):
            m = menu.Append(-1, 'Input:')
            m.Enable(False)
            for part in arrow.operation.input.parts:
                m = menu.Append(input_ids,
                                '%s (%s)' % (part.name, part.type.name))
                self.Bind(wx.EVT_MENU, self.OnArrowMenuOnArrowMenu, m)
                input_ids += 1
                    
            menu.AppendSeparator()
            m = menu.Append(-1, 'Output:')
            m.Enable(False)
            for part in arrow.operation.output.parts:
                m = menu.Append(output_ids,
                                '%s (%s)' % (part.name, part.type.name))
                self.Bind(wx.EVT_MENU, self.OnArrowMenuOnArrowMenu, m)
                output_ids += 1
        else:
            if arrow.type == 'input':
                if arrow.connectedTo:
                    m = menu.Append(input_ids, 'Input (%s)' % arrow.connectedTo)
                    self.Bind(wx.EVT_MENU, self.OnArrowMenuOnArrowMenu, m)
                else:
                    m = menu.Append(input_ids, 'Input')
                    self.Bind(wx.EVT_MENU, self.OnArrowMenuOnArrowMenu, m)
                m = menu.Append(-1, 'Provide input')
                self.Bind(wx.EVT_MENU, self.OnProvideInputOnProvideInput, m)
            else:
                if arrow.connectedTo:
                    m = menu.Append(output_ids, 'Input (%s)' % arrow.connectedTo)
                    self.Bind(wx.EVT_MENU, self.OnArrowMenuOnArrowMenu, m)
                else:
                    m = menu.Append(output_ids, 'Output')
                    self.Bind(wx.EVT_MENU, self.OnArrowMenuOnArrowMenu, m)
        
        menu.AppendSeparator()
        m = menu.Append(-1, 'Clear %s' % arrow.name)
        self.Bind(wx.EVT_MENU, self.OnClearShapeOnClearShape, m)
        m = menu.Append(-1, 'Rename %s' % arrow.name)
        self.Bind(wx.EVT_MENU, self.OnRenameShapeOnRenameShape, m)
                    
        return menu
    
    def OnClearShape(self, event):
        if self.selectedShapeselectedShape:
            to_remove = []
            for c in self.connectionsconnections:
                if c.input[0] == self.selectedShapeselectedShape or c.output[0] == self.selectedShapeselectedShape:
                    to_remove.append(c)
            for c in to_remove:
                self.connectionsconnections.remove(c)
            
            self.shapesshapes.remove(self.selectedShapeselectedShape)
            self.selectedShapeselectedShape = None
            self.Refresh()
    
    def OnRenameShape(self, event):
        if self.selectedShapeselectedShape:
            dlg = wx.TextEntryDialog(self, 'Please enter a new name.',
                                     'Rename', 'Python')
            dlg.SetValue(self.selectedShapeselectedShape.name)
            if dlg.ShowModal() == wx.ID_OK:
                self.selectedShapeselectedShape.Rename(dlg.GetValue())
            dlg.Destroy()
            self.Refresh()
    
    def OnProvideInput(self, event):
        pass
    
    def OnArrowMenu(self, event):
        menu_id = event.GetId()
        if self.dragFirst == None:
            if menu_id >= 3000 and menu_id < 4000:
                # input part selected:
                self.dragFirst = (self.dragArrow,
                                  True, menu_id - 3000)
            else:
                # output part selected:
                self.dragFirst = (self.dragArrow,
                                  False, menu_id - 4000)
        else:
            # make the connection
            if menu_id >= 3000 and menu_id < 4000:
                # input part selected:
                second = (self.dragArrow, True, menu_id - 3000)
            else:
                # output part selected:
                second = (self.dragArrow, False, menu_id - 4000)
            self.MakeConnection(self.dragFirst, second)
            self.ClearArrowDragging()
    
    def MakeConnection(self, first, second):
        # look if it is an output to input connection:
        if first[1] == second[1]:
            self.PrintErrorAndStopConnectingPrintErrorAndStopConnecting('Must connect input to output or vice versa')
        elif isinstance(first[0], InputOutputShape) and isinstance(second[0], InputOutputShape):
            self.PrintErrorAndStopConnectingPrintErrorAndStopConnecting('Cannot connect input directly to output')
        elif first[1] and isinstance(first[0], InputOutputShape):
            self.MakeInputConnectionMakeInputConnection(first, second)
        elif second[1] and isinstance(second[0], InputOutputShape):
            self.MakeInputConnectionMakeInputConnection(second, first)
        elif not first[1] and isinstance(first[0], InputOutputShape):
            self.MakeOutputConnectionMakeOutputConnection(first, second)
        elif not second[1] and isinstance(second[0], InputOutputShape):
            self.MakeOutputConnectionMakeOutputConnection(second, first)
        
        else:
            # look if the types match and make connection:
            part1 = first[0].operation
            part2 = second[0].operation
            if first[1]: # first is the input
                if part1.input.parts[first[2]].type.name != part2.output.parts[second[2]].type.name:
                    self.PrintErrorAndStopConnectingPrintErrorAndStopConnecting('Types don\'t match.')
                else:
                    self.connectionsconnections.append(Connection(self,
                                                       (first[0], first[2]),
                                                       (second[0], second[2])))
            else: # the second one is the input
                if part1.output.parts[first[2]].type.name != part2.input.parts[second[2]].type.name:
                    self.PrintErrorAndStopConnectingPrintErrorAndStopConnecting('Types don\'t match.')
                else:
                    self.connectionsconnections.append(Connection(self,
                                                       (second[0], second[2]),
                                                       (first[0], first[2])))
        self.Refresh()
        
    def MakeInputConnection(self, input, other):
        pass
    
    def MakeOutputConnection(self, output, other):
        pass
    
    def PrintErrorAndStopConnecting(self, msg):
        dlg = wx.MessageDialog(self, msg, 'Connection Error', wx.OK|wx.ICON_ERROR)
        dlg.ShowModal()
        dlg.Destroy()
        self.ClearArrowDragging()
    
    def round(self, n, m):
        x = n / m
        if n <= x * n + m / 2:
            return x * m
        else:
            return (x + 1) * m
    
    # Left mouse button up.
    def OnLeftUp(self, evt):
        if not self.dragImagedragImage or not self.dragShapedragShape:
            self.dragImagedragImage = None
            self.dragShapedragShape = None
            evt.Skip()
            return

        # Hide the image, end dragging, and nuke out the drag image.
        self.dragImagedragImage.Hide()
        self.dragImagedragImage.EndDrag()
        self.dragImagedragImage = None
        
        # use rounding to make it snappy to grid:
        self.dragShapedragShape.pos = (
            self.roundround(self.dragShapedragShape.pos[0] + evt.GetPosition()[0] - self.dragStartPos[0], 10), 
            self.roundround(self.dragShapedragShape.pos[1] + evt.GetPosition()[1] - self.dragStartPos[1], 10)
            )
        
        # move the shape to the end of the shapes so it will be on top:
        for s in self.shapesshapes:
            if s == self.dragShapedragShape:
                self.shapesshapes.remove(s)
        self.shapesshapes.append(self.dragShapedragShape)
        
        # show all connections to the shape:
        for c in self.connectionsconnections:
            if c.input[0] == self.dragShapedragShape or c.output[0] == self.dragShapedragShape:
                c.CalculateCoords()
                c.shown = True
        
        self.dragShapedragShape.shown = True
        self.RefreshRect(self.dragShapedragShape.GetRect())
        self.dragShapedragShape = None
        
        self.Refresh()


    # The mouse is moving
    def OnMotion(self, evt):
        # Ignore mouse movement if we're not dragging.
        if not self.dragShapedragShape or not evt.Dragging() or not evt.LeftIsDown():
            evt.Skip()

        # if we have a shape, but haven't started dragging yet
        if self.dragShapedragShape and not self.dragImagedragImage:

            # only start the drag after having moved a couple pixels
            tolerance = 2
            pt = evt.GetPosition()
            dx = abs(pt.x - self.dragStartPos.x)
            dy = abs(pt.y - self.dragStartPos.y)
            if dx <= tolerance and dy <= tolerance:
                return

            # erase the shape since it will be drawn independently now
            dc = wx.ClientDC(self)
            self.dragShapedragShape.shown = False
            self.EraseShapeEraseShape(self.dragShapedragShape, dc)
            
            # also all connections to this shape:
            for c in self.connectionsconnections:
                if c.input[0] == self.dragShapedragShape or c.output[0] == self.dragShapedragShape:
                    c.shown = False
            
            self.Refresh()

            self.dragImagedragImage = wx.DragImage(self.dragShapedragShape.bmp, 
                                          wx.StockCursor(wx.CURSOR_HAND))

            hotspot = self.dragStartPos - self.dragShapedragShape.pos
            self.dragImagedragImage.BeginDrag(hotspot, self, self.dragShapedragShape.fullscreen)

            self.dragImagedragImage.Move(pt)
            self.dragImagedragImage.Show()
            
        # if we have shape and image then move it, posibly highlighting another shape.
        elif self.dragShapedragShape and self.dragImagedragImage:
            # now move it and show it again if needed
            self.dragImagedragImage.Move(evt.GetPosition())
            self.dragImagedragImage.Show()


class ComplexRequestPanel(wx.Panel):
    def __init__(self, parent, connector):
        wx.Panel.__init__(self, parent, -1)
        
        self.defsdefs = None
        self.selected_serviceselected_service = None
        self.selected_portselected_port = None
        self.selected_operationselected_operation = None
        
        self.connconn = connector
        self.InitLayoutInitLayout()
    
    def InitLayout(self):
        mainbox = wx.BoxSizer(wx.VERTICAL)
        canvasbox = wx.StaticBox(self, -1, 'Constructor Window')
        cbs = wx.StaticBoxSizer(canvasbox, wx.HORIZONTAL)
        self.canvascanvas = DragCanvas(self, -1, self.defsdefs)
        
        mainbox.Add(self.InitHeadlineRowInitHeadlineRow(), 0, wx.EXPAND|wx.ALIGN_TOP|wx.ALL, 5)
        cbs.Add(self.canvascanvas, 1, wx.EXPAND)
        mainbox.Add(cbs, 1, wx.EXPAND|wx.ALL, 5)
        self.SetSizer(mainbox)
        
    def InitHeadlineRow(self):
        headlinerow = wx.BoxSizer(wx.HORIZONTAL)
        
        headlinerow.Add(wx.StaticText(self, -1, 'Select:'), 0, 
                        wx.RIGHT, 5)
        
        self.servicesservices = wx.Choice(self, -1, choices=[])
        headlinerow.Add(self.servicesservices, 1)
        self.Bind(wx.EVT_CHOICE, self.OnServiceSelectedOnServiceSelected, self.servicesservices)
        
        headlinerow.Add(wx.StaticText(self, -1, '>'), 0, wx.LEFT|wx.RIGHT, 5)
        
        self.portsports = wx.Choice(self, -1, choices=[])
        self.Bind(wx.EVT_CHOICE, self.OnPortSelectedOnPortSelected, self.portsports)
        headlinerow.Add(self.portsports, 1)
        
        headlinerow.Add(wx.StaticText(self, -1, '>'), 0, wx.LEFT|wx.RIGHT, 5)
        
        self.operationsoperations = wx.Choice(self, -1, choices=[])
        self.Bind(wx.EVT_CHOICE, self.OnOperationSelectedOnOperationSelected, self.operationsoperations)
        headlinerow.Add(self.operationsoperations, 1)
        
        headlinerow.Add(wx.StaticText(self, -1, 'or'), 0, wx.LEFT, 5)
        
        btn = wx.Button(self, -1, 'Add Input')
        self.Bind(wx.EVT_BUTTON, self.OnInputAddOnInputAdd, btn)
        headlinerow.Add(btn, 0, wx.LEFT, 5)
        
        btn = wx.Button(self, -1, 'Add Output')
        self.Bind(wx.EVT_BUTTON, self.OnOutputAddOnOutputAdd, btn)
        headlinerow.Add(btn, 0, wx.LEFT, 5)
        
        headlinerow.Add((5, -1), 1)
        
        btn = wx.Button(self, -1, 'Clear')
        self.Bind(wx.EVT_BUTTON, self.OnClearStructureOnClearStructure, btn)
        headlinerow.Add(btn, 0, wx.ALIGN_RIGHT|wx.RIGHT, 5)
        
        btn = wx.Button(self, -1, 'Execute')
        self.Bind(wx.EVT_BUTTON, self.OnExecuteOnExecute, btn)
        headlinerow.Add(btn, 0, wx.ALIGN_RIGHT)
        
        return headlinerow
    
    def OnInputAdd(self, event):
        self.canvascanvas.AddInput()
    
    def OnOutputAdd(self, event):
        self.canvascanvas.AddOutput()
    
    def OnServiceSelected(self, event):
        # clear the other two boxes and any selected ports and ops:
        self.portsports.Clear()
        self.operationsoperations.Clear()
        self.selected_serviceselected_service = None
        self.selected_portselected_port = None
        self.selected_operationselected_operation = None
        
        if self.defsdefs:
            sel = event.GetString()
            for s in self.defsdefs.services:
                if s.name == sel:
                    self.selected_serviceselected_service = s
                    self.portsports.AppendItems([pt.name for pt in s.ports])
                    break
    
    def OnPortSelected(self, event):
        self.operationsoperations.Clear()
        self.selected_portselected_port = None
        self.selected_operationselected_operation = None
        
        if self.selected_serviceselected_service:
            sel = event.GetString()
            for p in self.selected_serviceselected_service.ports:
                if p.name == sel:
                    self.selected_portselected_port = p
                    self.operationsoperations.AppendItems([op.name for op in p.type.operations])
                    break
    
    def OnOperationSelected(self, event):
        self.selected_operationselected_operation = None
        if self.selected_portselected_port:
            sel = event.GetString()
            for op in self.selected_portselected_port.type.operations:
                if op.name == sel:
                    self.selected_operationselected_operation = op
                    self.canvascanvas.AddOperation(self.selected_operationselected_operation)
    
    def SetDefs(self, defs):
        self.ClearDefinitionsClearDefinitions()
        self.defsdefs = defs
        self.canvascanvas.SetDefs(defs)
        if self.defsdefs:
            for svc in self.defsdefs.services:
                self.servicesservices.Append(svc.name)
    
    def OnExecute(self, event):
        pass
    
    def OnClearStructure(self, event):
        self.canvas.ClearAll()
    
    def ClearDefinitions(self):
        self.defsdefs = None
        self.selected_serviceselected_service = None
        self.selected_portselected_port = None
        self.selected_operationselected_operation = None
        self.ClearServiceListsClearServiceLists()
    
    def ClearServiceLists(self):
        self.servicesservices.Clear()
        self.operationsoperations.Clear()
        self.portsports.Clear()
        

---