1 # -*- coding: utf-8 -*-

     2 

     3 #This file is part of PLCOpenEditor, a library implementing an IEC 61131-3 editor

     4 #based on the plcopen standard. 

     5 #

     6 #Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

     7 #

     8 #See COPYING file for copyrights details.

     9 #

    10 #This library is free software; you can redistribute it and/or

    11 #modify it under the terms of the GNU General Public

    12 #License as published by the Free Software Foundation; either

    13 #version 2.1 of the License, or (at your option) any later version.

    14 #

    15 #This library is distributed in the hope that it will be useful,

    16 #but WITHOUT ANY WARRANTY; without even the implied warranty of

    17 #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    18 #General Public License for more details.

    19 #

    20 #You should have received a copy of the GNU General Public

    21 #License along with this library; if not, write to the Free Software

    22 #Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    23 

    24 import wx

    25 import wx.grid

    26 

    27 #-------------------------------------------------------------------------------

    28 #                            Action Block Dialog

    29 #-------------------------------------------------------------------------------

    30 

    31 def GetActionTableColnames():

    32     _ = lambda x: x

    33     return [_("Qualifier"), _("Duration"), _("Type"), _("Value"), _("Indicator")]

    34 

    35 def GetTypeList():

    36     _ = lambda x: x

    37     return [_("Action"), _("Variable"), _("Inline")]

    38 

    39 class ActionTable(wx.grid.PyGridTableBase):

    40     

    41     """

    42     A custom wx.Grid Table using user supplied data

    43     """

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

    45         # The base class must be initialized *first*

    46         wx.grid.PyGridTableBase.__init__(self)

    47         self.data = data

    48         self.colnames = colnames

    49         self.Parent = parent

    50         # XXX

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

    52         # see if the table has changed size

    53         self._rows = self.GetNumberRows()

    54         self._cols = self.GetNumberCols()

    55     

    56     def GetNumberCols(self):

    57         return len(self.colnames)

    58         

    59     def GetNumberRows(self):

    60         return len(self.data)

    61 

    62     def GetColLabelValue(self, col, translate=True):

    63         if col < len(self.colnames):

    64             colname = self.colnames[col]

    65             if translate:

    66                 return _(colname)

    67         return colname

    68 

    69     def GetRowLabelValues(self, row, translate=True):

    70         return row

    71 

    72     def GetValue(self, row, col):

    73         if row < self.GetNumberRows():

    74             colname = self.GetColLabelValue(col, False)

    75             name = str(self.data[row].get(colname, ""))

    76             if colname == "Type":

    77                 return _(name)

    78             return name

    79     

    80     def GetValueByName(self, row, colname):

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

    82 

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

    84         if col < len(self.colnames):

    85             colname = self.GetColLabelValue(col, False)

    86             if colname == "Type":

    87                 value = self.Parent.TranslateType[value]

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

    89         

    90     def ResetView(self, grid):

    91         """

    92         (wx.Grid) -> Reset the grid view.   Call this to

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

    94         """

    95         grid.BeginBatch()

    96         for current, new, delmsg, addmsg in [

    97             (self._rows, self.GetNumberRows(), wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED),

    98             (self._cols, self.GetNumberCols(), wx.grid.GRIDTABLE_NOTIFY_COLS_DELETED, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED),

    99         ]:

   100             if new < current:

   101                 msg = wx.grid.GridTableMessage(self,delmsg,new,current-new)

   102                 grid.ProcessTableMessage(msg)

   103             elif new > current:

   104                 msg = wx.grid.GridTableMessage(self,addmsg,new-current)

   105                 grid.ProcessTableMessage(msg)

   106                 self.UpdateValues(grid)

   107         grid.EndBatch()

   108 

   109         self._rows = self.GetNumberRows()

   110         self._cols = self.GetNumberCols()

   111         # update the column rendering scheme

   112         self._updateColAttrs(grid)

   113 

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

   115         grid.AdjustScrollbars()

   116         grid.ForceRefresh()

   117 

   118     def UpdateValues(self, grid):

   119         """Update all displayed values"""

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

   121         msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_REQUEST_VIEW_GET_VALUES)

   122         grid.ProcessTableMessage(msg)

   123 

   124     def _updateColAttrs(self, grid):

   125         """

   126         wx.Grid -> update the column attributes to add the

   127         appropriate renderer given the column name.

   128 

   129         Otherwise default to the default renderer.

   130         """

   131         

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

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

   134                 editor = None

   135                 renderer = None

   136                 readonly = False

   137                 colname = self.GetColLabelValue(col, False)

   138                 if colname == "Qualifier":

   139                     editor = wx.grid.GridCellChoiceEditor()

   140                     editor.SetParameters(self.Parent.QualifierList)

   141                 if colname == "Duration":

   142                     editor = wx.grid.GridCellTextEditor()

   143                     renderer = wx.grid.GridCellStringRenderer()

   144                     if self.Parent.DurationList[self.data[row]["Qualifier"]]:

   145                         readonly = False

   146                     else:

   147                         readonly = True

   148                         self.data[row]["Duration"] = ""

   149                 elif colname == "Type":

   150                     editor = wx.grid.GridCellChoiceEditor()

   151                     editor.SetParameters(self.Parent.TypeList)

   152                 elif colname == "Value":

   153                     type = self.data[row]["Type"]

   154                     if type == "Action":

   155                         editor = wx.grid.GridCellChoiceEditor()

   156                         editor.SetParameters(self.Parent.ActionList)

   157                     elif type == "Variable":

   158                         editor = wx.grid.GridCellChoiceEditor()

   159                         editor.SetParameters(self.Parent.VariableList)

   160                     elif type == "Inline":

   161                         editor = wx.grid.GridCellTextEditor()

   162                         renderer = wx.grid.GridCellStringRenderer()

   163                 elif colname == "Indicator":

   164                     editor = wx.grid.GridCellChoiceEditor()

   165                     editor.SetParameters(self.Parent.VariableList)

   166                     

   167                 grid.SetCellEditor(row, col, editor)

   168                 grid.SetCellRenderer(row, col, renderer)

   169                 grid.SetReadOnly(row, col, readonly)

   170                 

   171                 grid.SetCellBackgroundColour(row, col, wx.WHITE)

   172     

   173     def SetData(self, data):

   174         self.data = data

   175     

   176     def GetData(self):

   177         return self.data

   178     

   179     def GetCurrentIndex(self):

   180         return self.CurrentIndex

   181     

   182     def SetCurrentIndex(self, index):

   183         self.CurrentIndex = index

   184     

   185     def AppendRow(self, row_content):

   186         self.data.append(row_content)

   187 

   188     def RemoveRow(self, row_index):

   189         self.data.pop(row_index)

   190         

   191     def MoveRow(self, row_index, move, grid):

   192         new_index = max(0, min(row_index + move, len(self.data) - 1))

   193         if new_index != row_index:

   194             self.data.insert(new_index, self.data.pop(row_index))

   195             grid.SetGridCursor(new_index, grid.GetGridCursorCol())

   196 

   197     def Empty(self):

   198         self.data = []

   199         self.editors = []

   200 

   201 [ID_ACTIONBLOCKDIALOG, ID_ACTIONBLOCKDIALOGVARIABLESGRID, 

   202  ID_ACTIONBLOCKDIALOGSTATICTEXT1, ID_ACTIONBLOCKDIALOGADDBUTTON,

   203  ID_ACTIONBLOCKDIALOGDELETEBUTTON, ID_ACTIONBLOCKDIALOGUPBUTTON, 

   204  ID_ACTIONBLOCKDIALOGDOWNBUTTON, 

   205 ] = [wx.NewId() for _init_ctrls in range(7)]

   206 

   207 class ActionBlockDialog(wx.Dialog):

   208     

   209     if wx.VERSION < (2, 6, 0):

   210         def Bind(self, event, function, id = None):

   211             if id is not None:

   212                 event(self, id, function)

   213             else:

   214                 event(self, function)

   215     

   216     def _init_coll_flexGridSizer1_Items(self, parent):

   217         parent.AddSizer(self.TopSizer, 0, border=20, flag=wx.GROW|wx.TOP|wx.LEFT|wx.RIGHT)

   218         parent.AddSizer(self.GridButtonSizer, 0, border=20, flag=wx.ALIGN_RIGHT|wx.LEFT|wx.RIGHT)

   219         parent.AddSizer(self.ButtonSizer, 0, border=20, flag=wx.ALIGN_RIGHT|wx.BOTTOM|wx.LEFT|wx.RIGHT)

   220         

   221     def _init_coll_flexGridSizer1_Growables(self, parent):

   222         parent.AddGrowableCol(0)

   223         parent.AddGrowableRow(0)

   224         

   225     def _init_coll_TopSizer_Items(self, parent):

   226         parent.AddWindow(self.staticText1, 0, border=0, flag=wx.GROW)

   227         parent.AddWindow(self.ActionsGrid, 0, border=0, flag=wx.GROW)

   228     

   229     def _init_coll_TopSizer_Growables(self, parent):

   230         parent.AddGrowableCol(0)

   231         parent.AddGrowableRow(1)

   232 

   233     def _init_coll_GridButtonSizer_Items(self, parent):

   234         parent.AddWindow(self.AddButton, 0, border=10, flag=wx.GROW|wx.LEFT)

   235         parent.AddWindow(self.DeleteButton, 0, border=10, flag=wx.GROW|wx.LEFT)

   236         parent.AddWindow(self.UpButton, 0, border=10, flag=wx.GROW|wx.LEFT)

   237         parent.AddWindow(self.DownButton, 0, border=10, flag=wx.GROW|wx.LEFT)

   238 

   239     def _init_sizers(self):

   240         self.flexGridSizer1 = wx.FlexGridSizer(cols=1, hgap=0, rows=3, vgap=10)

   241         self.TopSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)

   242         self.GridButtonSizer = wx.BoxSizer(wx.HORIZONTAL)

   243         

   244         self._init_coll_flexGridSizer1_Items(self.flexGridSizer1)

   245         self._init_coll_flexGridSizer1_Growables(self.flexGridSizer1)

   246         self._init_coll_TopSizer_Items(self.TopSizer)

   247         self._init_coll_TopSizer_Growables(self.TopSizer)

   248         self._init_coll_GridButtonSizer_Items(self.GridButtonSizer)

   249         

   250         self.SetSizer(self.flexGridSizer1)

   251     

   252     def _init_ctrls(self, prnt):

   253         wx.Dialog.__init__(self, id=ID_ACTIONBLOCKDIALOG,

   254               name='ActionBlockDialog', parent=prnt, pos=wx.Point(376, 223),

   255               size=wx.Size(500, 300), style=wx.DEFAULT_DIALOG_STYLE|wx.RESIZE_BORDER,

   256               title=_('Edit action block properties'))

   257         self.SetClientSize(wx.Size(500, 300))

   258 

   259         self.staticText1 = wx.StaticText(id=ID_ACTIONBLOCKDIALOGSTATICTEXT1,

   260               label=_('Actions:'), name='staticText1', parent=self,

   261               pos=wx.Point(0, 0), size=wx.Size(0, 17), style=0)

   262 

   263         self.ActionsGrid = wx.grid.Grid(id=ID_ACTIONBLOCKDIALOGVARIABLESGRID,

   264               name='ActionsGrid', parent=self, pos=wx.Point(0, 0), 

   265               size=wx.Size(0, 0), style=wx.VSCROLL)

   266         self.ActionsGrid.SetFont(wx.Font(12, 77, wx.NORMAL, wx.NORMAL, False,

   267               'Sans'))

   268         self.ActionsGrid.SetLabelFont(wx.Font(10, 77, wx.NORMAL, wx.NORMAL,

   269               False, 'Sans'))

   270         self.ActionsGrid.DisableDragGridSize()

   271         self.ActionsGrid.EnableScrolling(False, True)

   272         self.ActionsGrid.Bind(wx.grid.EVT_GRID_CELL_CHANGE, self.OnActionsGridCellChange)

   273 

   274         self.AddButton = wx.Button(id=ID_ACTIONBLOCKDIALOGADDBUTTON, label=_('Add'),

   275               name='AddButton', parent=self, pos=wx.Point(0, 0),

   276               size=wx.DefaultSize, style=0)

   277         self.Bind(wx.EVT_BUTTON, self.OnAddButton, id=ID_ACTIONBLOCKDIALOGADDBUTTON)

   278 

   279         self.DeleteButton = wx.Button(id=ID_ACTIONBLOCKDIALOGDELETEBUTTON, label=_('Delete'),

   280               name='DeleteButton', parent=self, pos=wx.Point(0, 0),

   281               size=wx.DefaultSize, style=0)

   282         self.Bind(wx.EVT_BUTTON, self.OnDeleteButton, id=ID_ACTIONBLOCKDIALOGDELETEBUTTON)

   283 

   284         self.UpButton = wx.Button(id=ID_ACTIONBLOCKDIALOGUPBUTTON, label='^',

   285               name='UpButton', parent=self, pos=wx.Point(0, 0),

   286               size=wx.Size(32, 32), style=0)

   287         self.Bind(wx.EVT_BUTTON, self.OnUpButton, id=ID_ACTIONBLOCKDIALOGUPBUTTON)

   288 

   289         self.DownButton = wx.Button(id=ID_ACTIONBLOCKDIALOGDOWNBUTTON, label='v',

   290               name='DownButton', parent=self, pos=wx.Point(0, 0),

   291               size=wx.Size(32, 32), style=0)

   292         self.Bind(wx.EVT_BUTTON, self.OnDownButton, id=ID_ACTIONBLOCKDIALOGDOWNBUTTON)

   293 

   294         self.ButtonSizer = self.CreateButtonSizer(wx.OK|wx.CANCEL|wx.CENTRE)

   295         if wx.VERSION >= (2, 5, 0):

   296             self.Bind(wx.EVT_BUTTON, self.OnOK, id=self.ButtonSizer.GetAffirmativeButton().GetId())

   297         else:

   298             self.Bind(wx.EVT_BUTTON, self.OnOK, id=self.ButtonSizer.GetChildren()[0].GetSizer().GetChildren()[0].GetWindow().GetId())

   299         

   300         self._init_sizers()

   301 

   302     def __init__(self, parent):

   303         self._init_ctrls(parent)

   304         

   305         self.DefaultValue = {"Qualifier" : "N", "Duration" : "", "Type" : "Action", "Value" : "", "Indicator" : ""}

   306         self.Table = ActionTable(self, [], GetActionTableColnames())

   307         typelist = GetTypeList()       

   308         self.TypeList = ",".join(map(_,typelist))

   309         self.TranslateType = dict([(_(value), value) for value in typelist])

   310         self.ColSizes = [60, 90, 80, 110, 80]

   311         self.ColAlignements = [wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT, wx.ALIGN_LEFT]

   312         

   313         self.ActionsGrid.SetTable(self.Table)

   314         self.ActionsGrid.SetRowLabelSize(0)

   315         

   316         for col in range(self.Table.GetNumberCols()):

   317             attr = wx.grid.GridCellAttr()

   318             attr.SetAlignment(self.ColAlignements[col], wx.ALIGN_CENTRE)

   319             self.ActionsGrid.SetColAttr(col, attr)

   320             self.ActionsGrid.SetColMinimalWidth(col, self.ColSizes[col])

   321             self.ActionsGrid.AutoSizeColumn(col, False)

   322         

   323         self.Table.ResetView(self.ActionsGrid)

   324 

   325     def OnOK(self, event):

   326         self.ActionsGrid.SetGridCursor(0, 0)

   327         self.EndModal(wx.ID_OK)

   328 

   329     def OnAddButton(self, event):

   330         self.Table.AppendRow(self.DefaultValue.copy())

   331         self.Table.ResetView(self.ActionsGrid)

   332         event.Skip()

   333 

   334     def OnDeleteButton(self, event):

   335         row = self.ActionsGrid.GetGridCursorRow()

   336         self.Table.RemoveRow(row)

   337         self.Table.ResetView(self.ActionsGrid)

   338         event.Skip()

   339 

   340     def OnUpButton(self, event):

   341         row = self.ActionsGrid.GetGridCursorRow()

   342         self.Table.MoveRow(row, -1, self.ActionsGrid)

   343         self.Table.ResetView(self.ActionsGrid)

   344         event.Skip()

   345 

   346     def OnDownButton(self, event):

   347         row = self.ActionsGrid.GetGridCursorRow()

   348         self.Table.MoveRow(row, 1, self.ActionsGrid)

   349         self.Table.ResetView(self.ActionsGrid)

   350         event.Skip()

   351 

   352     def OnActionsGridCellChange(self, event):

   353         self.Table.ResetView(self.ActionsGrid)

   354         event.Skip()

   355 

   356     def SetQualifierList(self, list):

   357         self.QualifierList = "," + ",".join(list)

   358         self.DurationList = list

   359 

   360     def SetVariableList(self, list):

   361         self.VariableList = "," + ",".join([variable["Name"] for variable in list])

   362         

   363     def SetActionList(self, list):

   364         self.ActionList = "," + ",".join(list)

   365 

   366     def SetValues(self, actions):

   367         for action in actions:

   368             row = {"Qualifier" : action["qualifier"], "Value" : action["value"]}

   369             if action["type"] == "reference":

   370                 if action["value"] in self.ActionList:

   371                     row["Type"] = "Action"

   372                 elif action["value"] in self.VariableList:

   373                     row["Type"] = "Variable"

   374                 else:

   375                     row["Type"] = "Inline"

   376             else:

   377                 row["Type"] = "Inline"

   378             if "duration" in action:

   379                 row["Duration"] = action["duration"]

   380             else:

   381                 row["Duration"] = ""

   382             if "indicator" in action:

   383                 row["Indicator"] = action["indicator"]

   384             else:

   385                 row["Indicator"] = ""

   386             self.Table.AppendRow(row)

   387         self.Table.ResetView(self.ActionsGrid)

   388     

   389     def GetValues(self):

   390         values = []

   391         for data in self.Table.GetData():

   392             action = {"qualifier" : data["Qualifier"], "value" : data["Value"]}

   393             if data["Type"] in ["Action", "Variable"]:

   394                 action["type"] = "reference"

   395             else:

   396                 action["type"] = "inline"

   397             if data["Duration"] != "":

   398                 action["duration"] = data["Duration"]

   399             if data["Indicator"] != "":

   400                 action["indicator"] = data["Indicator"]

   401             values.append(action)

   402         return values