35 

    32 from graphics.SFC_Objects import *

    36 import re

    33 

    34 from Dialogs import *

    35 

    36 SCROLLBAR_UNIT = 10

    37 WINDOW_BORDER = 10

    38 SCROLL_ZONE = 10

   110         wx.ScrolledWindow.__init__(self, parent, style=wx.SUNKEN_BORDER)

   112         wx.ScrolledWindow.__init__(self, parent, style=wx.SUNKEN_BORDER | wx.HSCROLL | wx.VSCROLL)

   435                     end_connector = connected.GetConnector(wxPoint(points[-1][0], points[-1][1]))

   467                     end_connector = connected.GetConnector(wxPoint(points[-1][0], points[-1][1]), link["formalParameter"])

   651         event.Skip()

   845         keycode = event.GetKeyCode()

   846         if self.Scaling:

   847             scaling = self.Scaling

   848         else:

   849             scaling = (8, 8)

   850         if keycode == WXK_DELETE and self.SelectedElement:

   851             self.SelectedElement.Clean()

   852             self.SelectedElement.Delete()

   853             self.SelectedElement = None

   854         elif keycode == WXK_LEFT and self.SelectedElement:

   855             self.SelectedElement.Move(-scaling[0], 0)

   856         elif keycode == WXK_RIGHT and self.SelectedElement:

   857             self.SelectedElement.Move(scaling[0], 0)

   858         elif keycode == WXK_UP and self.SelectedElement:

   859             self.SelectedElement.Move(0, -scaling[1])

   860         elif keycode == WXK_DOWN and self.SelectedElement:

   861             self.SelectedElement.Move(0, scaling[1])

   862         self.Refresh()

   863         event.Skip()

   864 

   865 #-------------------------------------------------------------------------------

   866 #                          Model adding functions

   867 #-------------------------------------------------------------------------------

   868 

   869     def AddNewBlock(self, bbox):

   870         dialog = BlockPropertiesDialog(self.Parent)

   871         dialog.SetBlockList(self.Controler.GetBlockTypes())

   872         dialog.SetMinBlockSize((bbox.width, bbox.height))

   873         if dialog.ShowModal() == wxID_OK:

   874             id = self.GetNewId()

   875             values = dialog.GetValues()

   876             if "name" in values:

   877                 block = FBD_Block(self, values["type"], values["name"], id, values["extension"])

   878             else:

   879                 block = FBD_Block(self, values["type"], "", id, values["extension"])

   880             block.SetPosition(bbox.x, bbox.y)

   881             block.SetSize(values["width"], values["height"])

   882             self.Blocks.append(block)

   883             self.Elements.append(block)

   884             self.Controler.AddCurrentElementEditingBlock(id)

   885             self.RefreshBlockModel(block)

   886             self.Refresh()

   887         dialog.Destroy()

   888     

   889     def AddNewVariable(self, bbox):

   890         dialog = VariablePropertiesDialog(self.Parent)

   891         dialog.SetMinVariableSize((bbox.width, bbox.height))

   892         varlist = []

   893         vars = self.Controler.GetCurrentElementEditingInterfaceVars()

   894         if vars:

   895             for var in vars:

   896                 varlist.append((var["Name"], var["Class"], var["Type"]))

   897         returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()

   898         if returntype:

   899             varlist.append((self.Controler.GetCurrentElementEditingName(), "Output", returntype))

   900         dialog.SetVariables(varlist)

   901         if dialog.ShowModal() == wxID_OK:

   902             id = self.GetNewId()

   903             values = dialog.GetValues()

   904             variable = FBD_Variable(self, values["type"], values["name"], values["value_type"], id)

   905             variable.SetPosition(bbox.x, bbox.y)

   906             variable.SetSize(values["width"], values["height"])

   907             self.Blocks.append(variable)

   908             self.Elements.append(variable)

   909             self.Controler.AddCurrentElementEditingVariable(id, values["type"])

   910             self.RefreshVariableModel(variable)

   911             self.Refresh()

   912         dialog.Destroy()

   913 

   914     def AddNewConnection(self, bbox):

   915         dialog = ConnectionPropertiesDialog(self.Parent)

   916         dialog.SetMinConnectionSize((bbox.width, bbox.height))

   917         if dialog.ShowModal() == wxID_OK:

   918             id = self.GetNewId()

   919             values = dialog.GetValues()

   920             connection = FBD_Connector(self, values["type"], values["name"], id)

   921             connection.SetPosition(bbox.x, bbox.y)

   922             connection.SetSize(values["width"], values["height"])

   923             self.Blocks.append(connection)

   924             self.Elements.append(connection)

   925             self.Controler.AddCurrentElementEditingConnection(id, values["type"])

   926             self.RefreshConnectionModel(connection)

   927             self.Refresh()

   928         dialog.Destroy()

   929 

   930     def AddNewComment(self, bbox):

   931         dialog = wxTextEntryDialog(self.Parent, "Add a new comment", "Please enter comment text", "", wxOK|wxCANCEL|wxTE_MULTILINE)

   932         if dialog.ShowModal() == wxID_OK:

   933             value = dialog.GetValue()

   934             id = self.GetNewId()

   935             comment = Comment(self, value, id)

   936             comment.SetPosition(bbox.x, bbox.y)

   937             min_width, min_height = comment.GetMinSize()

   938             comment.SetSize(max(min_width,bbox.width),max(min_height,bbox.height))

   939             self.Elements.append(comment)

   940             self.Controler.AddCurrentElementEditingComment(id)

   941             self.RefreshCommentModel(comment)

   942             self.Refresh()

   943         dialog.Destroy()

   944 

   945     def AddNewContact(self, bbox):

   946         dialog = LDElementDialog(self.Parent, "contact")

   947         varlist = []

   948         vars = self.Controler.GetCurrentElementEditingInterfaceVars()

   949         if vars:

   950             for var in vars:

   951                 if var["Class"] != "Output" and var["Type"] == "BOOL":

   952                     varlist.append(var["Name"])

   953         dialog.SetVariables(varlist)

   954         dialog.SetValues({"name":"","type":CONTACT_NORMAL})

   955         dialog.SetElementSize(bbox.width, bbox.height)

   956         if dialog.ShowModal() == wxID_OK:

   957             id = self.GetNewId()

   958             values = dialog.GetValues()

   959             contact = LD_Contact(self, values["type"], values["name"], id)

   960             contact.SetPosition(bbox.x, bbox.y)

   961             contact.SetSize(values["width"], values["height"])

   962             self.Blocks.append(contact)

   963             self.Elements.append(contact)

   964             self.Controler.AddCurrentElementEditingContact(id)

   965             self.RefreshContactModel(contact)

   966             self.Refresh()

   967         dialog.Destroy()

   968 

   969     def AddNewCoil(self, bbox):

   970         dialog = LDElementDialog(self.Parent, "coil")

   971         varlist = []

   972         vars = self.Controler.GetCurrentElementEditingInterfaceVars()

   973         if vars:

   974             for var in vars:

   975                 if var["Class"] != "Input" and var["Type"] == "BOOL":

   976                     varlist.append(var["Name"])

   977         returntype = self.Controler.GetCurrentElementEditingInterfaceReturnType()

   978         if returntype == "BOOL":

   979             varlist.append(self.Controler.GetCurrentElementEditingName())

   980         dialog.SetVariables(varlist)

   981         dialog.SetValues({"name":"","type":COIL_NORMAL})

   982         dialog.SetElementSize(bbox.width, bbox.height)

   983         if dialog.ShowModal() == wxID_OK:

   984             id = self.GetNewId()

   985             values = dialog.GetValues()

   986             coil = LD_Coil(self, values["type"], values["name"], id)

   987             coil.SetPosition(bbox.x, bbox.y)

   988             coil.SetSize(values["width"], values["height"])

   989             self.Blocks.append(coil)

   990             self.Elements.append(coil)

   991             self.Controler.AddCurrentElementEditingCoil(id)

   992             self.RefreshCoilModel(contact)

   993             self.Refresh()

   994         dialog.Destroy()

   995 

   996     def AddNewPowerRail(self, bbox):

   997         dialog = LDPowerRailDialog(self.Parent)

   998         dialog.SetMinSize((bbox.width, bbox.height))

   999         if dialog.ShowModal() == wxID_OK:

  1000             id = self.GetNewId()

  1001             values = dialog.GetValues()

  1002             powerrail = LD_PowerRail(self, values["type"], id, [True for i in xrange(values["number"])])

  1003             powerrail.SetPosition(bbox.x, bbox.y)

  1004             powerrail.SetSize(values["width"], values["height"])

  1005             self.Blocks.append(powerrail)

  1006             self.Elements.append(powerrail)

  1007             self.Controler.AddCurrentElementEditingPowerRail(id, values["type"])

  1008             self.RefreshPowerRailModel(powerrail)

  1009             self.Refresh()

  1010         dialog.Destroy()

  1011 

  1012     def AddNewTransition(self, bbox):

  1013         dialog = TransitionContentDialog(self.Parent)

  1014         dialog.SetTransitions(self.Controler.GetCurrentElementEditingTransitions())

  1015         if dialog.ShowModal() == wxID_OK:

  1016             id = self.GetNewId()

  1017             values = dialog.GetValues()

  1018             transition = SFC_Transition(self, values["type"], values["value"], id)

  1019             transition.SetPosition(bbox.x, bbox.y)

  1020             min_width, min_height = transition.GetMinSize()

  1021             transition.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))

  1022             self.Blocks.append(transition)

  1023             self.Elements.append(transition)

  1024             self.Controler.AddCurrentElementEditingTransition(id)

  1025             self.RefreshTransitionModel(transition)

  1026             self.Refresh()

  1027         dialog.Destroy()

  1028 

  1029     def AddNewDivergence(self, bbox):

  1030         dialog = DivergenceCreateDialog(self.Parent)

  1031         dialog.SetMinSize((bbox.width, bbox.height))

  1032         if dialog.ShowModal() == wxID_OK:

  1033             id = self.GetNewId()

  1034             values = dialog.GetValues()

  1035             divergence = SFC_Divergence(self, values["type"], values["number"], id)

  1036             divergence.SetPosition(bbox.x, bbox.y)

  1037             min_width, min_height = divergence.GetMinSize()

  1038             divergence.SetSize(max(bbox.width, min_width), max(bbox.height, min_height))

  1039             self.Blocks.append(divergence)

  1040             self.Elements.append(divergence)

  1041             self.Controler.AddCurrentElementEditingDivergence(id, values["type"])

  1042             self.RefreshDivergenceModel(divergence)

  1043             self.Refresh()

  1044         dialog.Destroy()

   785         dc = wxClientDC(self)

  1322         dc = self.GetLogicalDC()

   802         event.Skip()

  1339         if self.rubberBand.IsShown():

   803 

  1340             self.rubberBand.Draw()

   804 

  1341         event.Skip()

   805 #-------------------------------------------------------------------------------

  1342 

   806 #                         Textual programs Viewer class

  1343 

   807 #-------------------------------------------------------------------------------

   808 

   809 

   810 NEWLINE = "\n"

   811 NUMBERS = [str(i) for i in xrange(10)]

   812 LETTERS = ['_']

   813 for i in xrange(26):

   814     LETTERS.append(chr(ord('a') + i))

   815     LETTERS.append(chr(ord('A') + i))

   816 

   817 [wxSTC_PLC_WORD, wxSTC_PLC_COMMENT, wxSTC_PLC_NUMBER, wxSTC_PLC_VARIABLE, 

   818  wxSTC_PLC_FUNCTION, wxSTC_PLC_JUMP] = range(6)

   819 [SPACE, WORD, NUMBER, COMMENT] = range(4)

   820 

   821 [wxID_TEXTVIEWER,

   822 ] = [wx.NewId() for _init_ctrls in range(1)]

   823 

   824 if wx.Platform == '__WXMSW__':

   825     faces = { 'times': 'Times New Roman',

   826               'mono' : 'Courier New',

   827               'helv' : 'Arial',

   828               'other': 'Comic Sans MS',

   829               'size' : 10,

   830              }

   831 else:

   832     faces = { 'times': 'Times',

   833               'mono' : 'Courier',

   834               'helv' : 'Helvetica',

   835               'other': 'new century schoolbook',

   836               'size' : 12,

   837              }

   838 re_texts = {}

   839 re_texts["letter"] = "[A-Za-z]"

   840 re_texts["digit"] = "[0-9]"

   841 re_texts["identifier"] = "((?:%(letter)s|(?:_(?:%(letter)s|%(digit)s)))(?:_?(?:%(letter)s|%(digit)s))*)"%re_texts

   842 IDENTIFIER_MODEL = re.compile(re_texts["identifier"])

   843 LABEL_MODEL = re.compile("[ \t\n]%(identifier)s:[ \t\n]"%re_texts)

   844 

   845 class TextViewer(wxStyledTextCtrl):

   846     

   847     def __init__(self, parent, window, controler):

   848         wxStyledTextCtrl.__init__(self, parent, wxID_TEXTVIEWER, style=0)

   849         

   850         self.CmdKeyAssign(ord('+'), wxSTC_SCMOD_CTRL, wxSTC_CMD_ZOOMIN)

   851         self.CmdKeyAssign(ord('-'), wxSTC_SCMOD_CTRL, wxSTC_CMD_ZOOMOUT)

   852         

   853         self.SetViewWhiteSpace(False)

   854         

   855         self.SetLexer(wxSTC_LEX_CONTAINER)

   856         

   857         # Global default styles for all languages

   858         self.StyleSetSpec(wxSTC_STYLE_DEFAULT, "face:%(mono)s,size:%(size)d" % faces)

   859         self.StyleClearAll()  # Reset all to be like the default

   860         

   861         self.StyleSetSpec(wxSTC_STYLE_LINENUMBER,  "back:#C0C0C0,size:%(size)d" % faces)

   862         self.SetSelBackground(1, "#E0E0E0")

   863         

   864         # Highlighting styles

   865         self.StyleSetSpec(wxSTC_PLC_WORD, "fore:#00007F,bold,size:%(size)d" % faces)

   866         self.StyleSetSpec(wxSTC_PLC_VARIABLE, "fore:#7F0000,size:%(size)d" % faces)

   867         self.StyleSetSpec(wxSTC_PLC_FUNCTION, "fore:#7F7F00,size:%(size)d" % faces)

   868         self.StyleSetSpec(wxSTC_PLC_COMMENT, "fore:#7F7F7F,size:%(size)d" % faces)

   869         self.StyleSetSpec(wxSTC_PLC_NUMBER, "fore:#007F7F,size:%(size)d" % faces)

   870         self.StyleSetSpec(wxSTC_PLC_JUMP, "fore:#007F00,size:%(size)d" % faces)

   871         

   872         # Indicators styles

   873         self.IndicatorSetStyle(0, wxSTC_INDIC_SQUIGGLE)

   874         self.IndicatorSetForeground(0, wxRED)

   875         

   876         # Line numbers in the margin

   877         self.SetMarginType(1, wxSTC_MARGIN_NUMBER)

   878         self.SetMarginWidth(1, 50)

   879         

   880         # Indentation size

   881         self.SetTabWidth(2)

   882         self.SetUseTabs(0)

   883         

   884         self.Keywords = []

   885         self.Variables = []

   886         self.Functions = []

   887         self.Jumps = []

   888         self.TextChanged = False

   889         self.TextSyntax = "ST"

   890         

   891         self.Controler = controler

   892 

   893         EVT_KEY_DOWN(self, self.OnKeyDown)

   894         EVT_STC_STYLENEEDED(self, wxID_TEXTVIEWER, self.OnStyleNeeded)

   895         EVT_KILL_FOCUS(self, self.OnKillFocus)

   896     

   897     def SetTextSyntax(self, syntax):

   898         self.TextSyntax = syntax

   899     

   900     def SetKeywords(self, keywords):

   901         self.Keywords = [keyword.upper() for keyword in keywords]

   902         self.Colourise(0, -1)

   903     

   904     def SetVariables(self, variables):

   905         self.Variables = [variable.upper() for variable in variables]

   906         self.Colourise(0, -1)

   907     

   908     def SetFunctions(self, blocktypes):

   909         self.Functions = []

   910         for category in blocktypes:

   911             for blocktype in category["list"]:

   912                 if blocktype["name"] not in self.Keywords and blocktype["name"] not in self.Variables:

   913                     self.Functions.append(blocktype["name"].upper())

   914         self.Colourise(0, -1)

   915     

   916     def RefreshJumpList(self):

   917         self.Jumps = [jump.upper() for jump in LABEL_MODEL.findall(self.GetText())]

   918         self.Colourise(0, -1)

   919     

   920     def RefreshView(self):

   921         self.SetText(self.Controler.GetCurrentElementEditingText())

   922         self.RefreshJumpList()

   923     

   924     def OnStyleNeeded(self, event):

   925         self.TextChanged = True

   926         line = self.LineFromPosition(self.GetEndStyled())

   927         if line == 0:

   928             start_pos = 0

   929         else:

   930             start_pos = self.GetLineEndPosition(line - 1) + 1

   931         end_pos = event.GetPosition()

   932         self.StartStyling(start_pos, 0xff)

   933         

   934         i = start_pos

   935         state = SPACE

   936         line = ""

   937         word = ""

   938         while i < end_pos:

   939             char = chr(self.GetCharAt(i)).upper()

   940             line += char

   941             if char == NEWLINE:

   942                 if state == COMMENT:

   943                     self.SetStyling(i - start_pos + 1, wxSTC_PLC_COMMENT)

   944                 elif state == NUMBER:

   945                     self.SetStyling(i - start_pos, wxSTC_PLC_NUMBER)

   946                 elif state == WORD:

   947                     if word in self.Keywords:

   948                         self.SetStyling(i - start_pos, wxSTC_PLC_WORD)

   949                     elif word in self.Variables:

   950                         self.SetStyling(i - start_pos, wxSTC_PLC_VARIABLE)

   951                     elif word in self.Functions:

   952                         self.SetStyling(i - start_pos, wxSTC_PLC_FUNCTION)

   953                     elif word in self.Jumps:

   954                         self.SetStyling(i - start_pos, wxSTC_PLC_JUMP)

   955                     else:

   956                         self.SetStyling(i - start_pos, 31)

   957                         if self.GetCurrentPos() < start_pos or self.GetCurrentPos() > i:

   958                             self.StartStyling(start_pos, wxSTC_INDICS_MASK)

   959                             self.SetStyling(i - start_pos, wxSTC_INDIC0_MASK)

   960                             self.StartStyling(i, 0xff)    

   961                 else:

   962                     self.SetStyling(i - start_pos, 31)

   963                 start_pos = i

   964                 state = SPACE

   965                 line = ""

   966             elif line.endswith("(*") and state != COMMENT:

   967                 self.SetStyling(i - start_pos - 1, 31)

   968                 start_pos = i

   969                 state = COMMENT

   970             elif state == COMMENT:

   971                 if line.endswith("*)"):

   972                     self.SetStyling(i - start_pos + 2, wxSTC_PLC_COMMENT)

   973                     start_pos = i + 1

   974                     state = SPACE

   975             elif char in LETTERS:

   976                 if state == NUMBER:

   977                     word = "#"

   978                     state = WORD

   979                 elif state == SPACE:

   980                     self.SetStyling(i - start_pos, 31)

   981                     word = char

   982                     start_pos = i

   983                     state = WORD

   984                 else:

   985                     word += char

   986             elif char in NUMBERS or char == '.' and state != WORD:

   987                 if state == SPACE:

   988                     self.SetStyling(i - start_pos, 31)

   989                     start_pos = i

   990                     state = NUMBER

   991                 if state == WORD and char != '.':

   992                     word += char

   993             else:

   994                 if state == WORD:

   995                     if word in self.Keywords:

   996                         self.SetStyling(i - start_pos, wxSTC_PLC_WORD)

   997                     elif word in self.Variables:

   998                         self.SetStyling(i - start_pos, wxSTC_PLC_VARIABLE)

   999                     elif word in self.Functions:

  1000                         self.SetStyling(i - start_pos, wxSTC_PLC_FUNCTION)

  1001                     elif word in self.Jumps:

  1002                         self.SetStyling(i - start_pos, wxSTC_PLC_JUMP)

  1003                     else:

  1004                         self.SetStyling(i - start_pos, 31)

  1005                         if self.GetCurrentPos() < start_pos or self.GetCurrentPos() > i:

  1006                             self.StartStyling(start_pos, wxSTC_INDICS_MASK)

  1007                             self.SetStyling(i - start_pos, wxSTC_INDIC0_MASK)

  1008                             self.StartStyling(i, 0xff)

  1009                     word = ""

  1010                     start_pos = i

  1011                     state = SPACE

  1012                 elif state == NUMBER:

  1013                     self.SetStyling(i - start_pos, wxSTC_PLC_NUMBER)

  1014                     start_pos = i

  1015                     state = SPACE

  1016             i += 1

  1017         if state == COMMENT:

  1018             self.SetStyling(i - start_pos + 2, wxSTC_PLC_COMMENT)

  1019         elif state == NUMBER:

  1020             self.SetStyling(i - start_pos, wxSTC_PLC_NUMBER)

  1021         elif state == WORD:

  1022             if word in self.Keywords:

  1023                 self.SetStyling(i - start_pos, wxSTC_PLC_WORD)

  1024             elif word in self.Variables:

  1025                 self.SetStyling(i - start_pos, wxSTC_PLC_VARIABLE)

  1026             elif word in self.Functions:

  1027                 self.SetStyling(i - start_pos, wxSTC_PLC_FUNCTION)

  1028             elif word in self.Jumps:

  1029                 self.SetStyling(i - start_pos, wxSTC_PLC_JUMP)

  1030             else:

  1031                 self.SetStyling(i - start_pos, 31)

  1032         else:

  1033             self.SetStyling(i - start_pos, 31)

  1034         event.Skip()

  1035     

  1036     def Cut(self):

  1037         self.CmdKeyExecute(wxSTC_CMD_CUT)

  1038         

  1039     def Copy(self):

  1040         self.CmdKeyExecute(wxSTC_CMD_COPY)

  1041     

  1042     def Paste(self):

  1043         self.CmdKeyExecute(wxSTC_CMD_PASTE)

  1044     

  1045     def RefreshModel(self):

  1046         if self.TextChanged:

  1047             self.RefreshJumpList()

  1048             self.Controler.SetCurrentElementEditingText(self.GetText())

  1049     

  1050     def OnKeyDown(self, event):

  1051         if self.CallTipActive():

  1052             self.CallTipCancel()

  1053         key = event.KeyCode()

  1054 

  1055         # Code completion

  1056         if key == WXK_SPACE and event.ControlDown():

  1057             

  1058             line = self.GetCurrentLine()

  1059             if line == 0:

  1060                 start_pos = 0

  1061             else:

  1062                 start_pos = self.GetLineEndPosition(line - 1) + 1

  1063             end_pos = self.GetCurrentPos()

  1064 

  1065             lineText = self.GetTextRange(start_pos, end_pos).replace("\t", " ")

  1066             words = lineText.split(" ")

  1067             words = [word for i, word in enumerate(words) if word != '' or i == len(words) - 1]

  1068                         

  1069             kw = []

  1070             

  1071             if self.TextSyntax == "IL":

  1072                 if len(words) == 1:

  1073                     kw = self.Keywords

  1074                 elif len(words) == 2:

  1075                     if words[0].upper() in ["CAL", "CALC", "CALNC"]:

  1076                         kw = self.Functions

  1077                     elif words[0].upper() in ["JMP", "JMPC", "JMPNC"]:

  1078                         kw = self.Jumps

  1079                     else:

  1080                         kw = self.Variables

  1081             else:

  1082                 kw = self.Keywords + self.Variables + self.Functions

  1083             if len(kw) > 0:

  1084                 kw.sort()

  1085                 self.AutoCompSetIgnoreCase(True)

  1086                 self.AutoCompShow(len(words[-1]), " ".join(kw))

  1087         else:

  1088             self.TextChanged = False

  1089             wxCallAfter(self.RefreshModel)

  1090             event.Skip()

  1091 

  1092     def OnKillFocus(self, event):

  1093         self.AutoCompCancel()

  1094         event.Skip()

  1095 

  1096 

  1097 #-------------------------------------------------------------------------------

  1098 #                            Resource Editor class

  1099 #-------------------------------------------------------------------------------

  1100 

  1101 class ResourceTable(wxPyGridTableBase):

  1102     

  1103     """

  1104     A custom wxGrid Table using user supplied data

  1105     """

  1106     def __init__(self, parent, data, colnames):

  1107         # The base class must be initialized *first*

  1108         wxPyGridTableBase.__init__(self)

  1109         self.data = data

  1110         self.colnames = colnames

  1111         self.Parent = parent

  1112         

  1113         self.ColAlignements = []

  1114         self.ColSizes = []

  1115         # XXX

  1116         # we need to store the row length and collength to

  1117         # see if the table has changed size

  1118         self._rows = self.GetNumberRows()

  1119         self._cols = self.GetNumberCols()

  1120     

  1121     def GetColAlignements(self):

  1122         return self.ColAlignements

  1123     

  1124     def SetColAlignements(self, list):

  1125         self.ColAlignements = list

  1126 

  1127     def GetColSizes(self):

  1128         return self.ColSizes

  1129     

  1130     def SetColSizes(self, list):

  1131         self.ColSizes = list

  1132 

  1133     def GetNumberCols(self):

  1134         return len(self.colnames)

  1135         

  1136     def GetNumberRows(self):

  1137         return len(self.data)

  1138 

  1139     def GetColLabelValue(self, col):

  1140         if col < len(self.colnames):

  1141             return self.colnames[col]

  1142 

  1143     def GetRowLabelValues(self, row):

  1144         return row

  1145 

  1146     def GetValue(self, row, col):

  1147         if row < self.GetNumberRows():

  1148             name = str(self.data[row].get(self.GetColLabelValue(col), ""))

  1149             return name

  1150     

  1151     def GetValueByName(self, row, colname):

  1152         return self.data[row].get(colname)

  1153 

  1154     def SetValue(self, row, col, value):

  1155         if col < len(self.colnames):

  1156             self.data[row][self.GetColLabelValue(col)] = value

  1157     

  1158     def SetValueByName(self, row, colname, value):

  1159         if colname in self.colnames:

  1160             self.data[row][colname] = value

  1161     

  1162     def ResetView(self, grid):

  1163         """

  1164         (wxGrid) -> Reset the grid view.   Call this to

  1165         update the grid if rows and columns have been added or deleted

  1166         """

  1167         grid.BeginBatch()

  1168         for current, new, delmsg, addmsg in [

  1169             (self._rows, self.GetNumberRows(), wxGRIDTABLE_NOTIFY_ROWS_DELETED, wxGRIDTABLE_NOTIFY_ROWS_APPENDED),

  1170             (self._cols, self.GetNumberCols(), wxGRIDTABLE_NOTIFY_COLS_DELETED, wxGRIDTABLE_NOTIFY_COLS_APPENDED),

  1171         ]:

  1172             if new < current:

  1173                 msg = wxGridTableMessage(self,delmsg,new,current-new)

  1174                 grid.ProcessTableMessage(msg)

  1175             elif new > current:

  1176                 msg = wxGridTableMessage(self,addmsg,new-current)

  1177                 grid.ProcessTableMessage(msg)

  1178                 self.UpdateValues(grid)

  1179         grid.EndBatch()

  1180 

  1181         self._rows = self.GetNumberRows()

  1182         self._cols = self.GetNumberCols()

  1183         # update the column rendering scheme

  1184         self._updateColAttrs(grid)

  1185 

  1186         # update the scrollbars and the displayed part of the grid

  1187         grid.AdjustScrollbars()

  1188         grid.ForceRefresh()

  1189 

  1190     def UpdateValues(self, grid):

  1191         """Update all displayed values"""

  1192         # This sends an event to the grid table to update all of the values

  1193         msg = wxGridTableMessage(self, wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)

  1194         grid.ProcessTableMessage(msg)

  1195 

  1196     def _updateColAttrs(self, grid):

  1197         """

  1198         wxGrid -> update the column attributes to add the

  1199         appropriate renderer given the column name.

  1200 

  1201         Otherwise default to the default renderer.

  1202         """

  1203         

  1204         for col in range(self.GetNumberCols()):

  1205             attr = wxGridCellAttr()

  1206             attr.SetAlignment(self.ColAlignements[col], wxALIGN_CENTRE)

  1207             grid.SetColAttr(col, attr)

  1208             grid.SetColSize(col, self.ColSizes[col])

  1209         

  1210         for row in range(self.GetNumberRows()):

  1211             for col in range(self.GetNumberCols()):

  1212                 editor = None

  1213                 renderer = None

  1214                 colname = self.GetColLabelValue(col)

  1215                 grid.SetReadOnly(row, col, False)

  1216                 if colname in ["Name","Interval"]:

  1217                     editor = wxGridCellTextEditor()

  1218                     renderer = wxGridCellStringRenderer()

  1219                     if colname == "Interval" and self.GetValueByName(row, "Single") != "":

  1220                         grid.SetReadOnly(row, col, True)

  1221                 elif colname == "Single":

  1222                     editor = wxGridCellChoiceEditor()

  1223                     editor.SetParameters(self.Parent.VariableList)

  1224                     if self.GetValueByName(row, "Interval") != "":

  1225                         grid.SetReadOnly(row, col, True)

  1226                 elif colname == "Type":

  1227                     editor = wxGridCellChoiceEditor()

  1228                     editor.SetParameters(self.Parent.TypeList)

  1229                 elif colname == "Priority":

  1230                     editor = wxGridCellNumberEditor()

  1231                     editor.SetParameters("0,65535")

  1232                 elif colname == "Task":

  1233                     editor = wxGridCellChoiceEditor()

  1234                     editor.SetParameters(self.Parent.TaskList)

  1235                     

  1236                 grid.SetCellEditor(row, col, editor)

  1237                 grid.SetCellRenderer(row, col, renderer)

  1238                 

  1239                 grid.SetCellBackgroundColour(row, col, wxWHITE)

  1240     

  1241     def SetData(self, data):

  1242         self.data = data

  1243     

  1244     def GetData(self):

  1245         return self.data

  1246     

  1247     def GetCurrentIndex(self):

  1248         return self.CurrentIndex

  1249     

  1250     def SetCurrentIndex(self, index):

  1251         self.CurrentIndex = index

  1252     

  1253     def AppendRow(self, row_content):

  1254         self.data.append(row_content)

  1255