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

from controls import CustomGrid

    28

    29

#-------------------------------------------------------------------------------

    30

#                            Action Block Dialog

    31

#-------------------------------------------------------------------------------

    32

    33

def GetActionTableColnames():

    34

    _ = lambda x: x

    35

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

    36

    37

def GetTypeList():

    38

    _ = lambda x: x

    39

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

    40

    41

class ActionTable(wx.grid.PyGridTableBase):

    42

    43

    """

    44

    A custom wx.Grid Table using user supplied data

    45

    """

    46

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

    47

        # The base class must be initialized *first*

    48

        wx.grid.PyGridTableBase.__init__(self)

    49

        self.data = data

    50

        self.colnames = colnames

    51

        self.Parent = parent

    52

        # XXX

    53

        # we need to store the row length and collength to

    54

        # see if the table has changed size

    55

        self._rows = self.GetNumberRows()

    56

        self._cols = self.GetNumberCols()

    57

    58

    def GetNumberCols(self):

    59

        return len(self.colnames)

    60

    61

    def GetNumberRows(self):

    62

        return len(self.data)

    63

    64

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

    65

        if col < len(self.colnames):

    66

            colname = self.colnames[col]

    67

            if translate:

    68

                return _(colname)

    69

        return colname

    70

    71

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

    72

        return row

    73

    74

    def GetValue(self, row, col):

    75

        if row < self.GetNumberRows():

    76

            colname = self.GetColLabelValue(col, False)

    77

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

    78

            if colname == "Type":

    79

                return _(name)

    80

            return name

    81

    82

    def GetValueByName(self, row, colname):

    83

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

    84

    85

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

    86

        if col < len(self.colnames):

    87

            colname = self.GetColLabelValue(col, False)

    88

            if colname == "Type":

    89

                value = self.Parent.TranslateType[value]

    90

            self.data[row][colname] = value

    91

    92

    def ResetView(self, grid):

    93

        """

    94

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

    95

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

    96

        """

    97

        grid.BeginBatch()

    98

        for current, new, delmsg, addmsg in [

    99

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

   100

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

   101

        ]:

   102

            if new < current:

   103

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

   104

                grid.ProcessTableMessage(msg)

   105

            elif new > current:

   106

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

   107

                grid.ProcessTableMessage(msg)

   108

                self.UpdateValues(grid)

   109

        grid.EndBatch()

   110

   111

        self._rows = self.GetNumberRows()

   112

        self._cols = self.GetNumberCols()

   113

        # update the column rendering scheme

   114

        self._updateColAttrs(grid)

   115

   116

        # update the scrollbars and the displayed part of the grid

   117

        grid.AdjustScrollbars()

   118

        grid.ForceRefresh()

   119

   120

    def UpdateValues(self, grid):

   121

        """Update all displayed values"""

   122

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

   123

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

   124

        grid.ProcessTableMessage(msg)

   125

   126

    def _updateColAttrs(self, grid):

   127

        """

   128

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

   129

        appropriate renderer given the column name.

   130

   131

        Otherwise default to the default renderer.

   132

        """

   133

   134

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

   135

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

   136

                editor = None

   137

                renderer = None

   138

                readonly = False

   139

                colname = self.GetColLabelValue(col, False)

   140

                if colname == "Qualifier":

   141

                    editor = wx.grid.GridCellChoiceEditor()

   142

                    editor.SetParameters(self.Parent.QualifierList)

   143

                if colname == "Duration":

   144

                    editor = wx.grid.GridCellTextEditor()

   145

                    renderer = wx.grid.GridCellStringRenderer()

   146

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

   147

                        readonly = False

   148

                    else:

   149

                        readonly = True

   150

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

   151

                elif colname == "Type":

   152

                    editor = wx.grid.GridCellChoiceEditor()

   153

                    editor.SetParameters(self.Parent.TypeList)

   154

                elif colname == "Value":

   155

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

   156

                    if type == "Action":

   157

                        editor = wx.grid.GridCellChoiceEditor()

   158

                        editor.SetParameters(self.Parent.ActionList)

   159

                    elif type == "Variable":

   160

                        editor = wx.grid.GridCellChoiceEditor()

   161

                        editor.SetParameters(self.Parent.VariableList)

   162

                    elif type == "Inline":

   163

                        editor = wx.grid.GridCellTextEditor()

   164

                        renderer = wx.grid.GridCellStringRenderer()

   165

                elif colname == "Indicator":

   166

                    editor = wx.grid.GridCellChoiceEditor()

   167

                    editor.SetParameters(self.Parent.VariableList)

   168

   169

                grid.SetCellEditor(row, col, editor)

   170

                grid.SetCellRenderer(row, col, renderer)

   171

                grid.SetReadOnly(row, col, readonly)

   172

   173

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

   174

            if wx.Platform == '__WXMSW__':

   175

                grid.SetRowMinimalHeight(row, 20)

   176

            else:

   177

                grid.SetRowMinimalHeight(row, 28)

   178

            grid.AutoSizeRow(row, False)

   179

   180

    def SetData(self, data):

   181

        self.data = data

   182

   183

    def GetData(self):

   184

        return self.data

   185

   186

    def GetCurrentIndex(self):

   187

        return self.CurrentIndex

   188

   189

    def SetCurrentIndex(self, index):

   190

        self.CurrentIndex = index

   191

   192

    def AppendRow(self, row_content):

   193

        self.data.append(row_content)

   194

   195

    def InsertRow(self, row_index, row_content):

   196

        self.data.insert(row_index, row_content)

   197

   198

    def RemoveRow(self, row_index):

   199

        self.data.pop(row_index)

   200

   201

    def MoveRow(self, row_index, move):

   202

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

   203

        if new_index != row_index:

   204

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

   205

        return new_index

   206

   207

    def Empty(self):

   208

        self.data = []

   209

   210

[ID_ACTIONBLOCKDIALOG, ID_ACTIONBLOCKDIALOGVARIABLESGRID, 

   211

 ID_ACTIONBLOCKDIALOGSTATICTEXT1, ID_ACTIONBLOCKDIALOGADDBUTTON,

   212

 ID_ACTIONBLOCKDIALOGDELETEBUTTON, ID_ACTIONBLOCKDIALOGUPBUTTON, 

   213

 ID_ACTIONBLOCKDIALOGDOWNBUTTON, 

   214

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

   215

   216

class ActionBlockDialog(wx.Dialog):

   217

   218

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

   219

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

   220

            if id is not None:

   221

                event(self, id, function)

   222

            else:

   223

                event(self, function)

   224

   225

    def _init_coll_flexGridSizer1_Items(self, parent):

   226

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

   227

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

   228

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

   229

   230

    def _init_coll_flexGridSizer1_Growables(self, parent):

   231

        parent.AddGrowableCol(0)

   232

        parent.AddGrowableRow(0)

   233

   234

    def _init_coll_TopSizer_Items(self, parent):

   235

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

   236

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

   237

   238

    def _init_coll_TopSizer_Growables(self, parent):

   239

        parent.AddGrowableCol(0)

   240

        parent.AddGrowableRow(1)

   241

   242

    def _init_coll_GridButtonSizer_Items(self, parent):

   243

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

   244

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

   245

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

   246

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

   247

   248

    def _init_sizers(self):

   249

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

   250

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

   251

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

   252

   253

        self._init_coll_flexGridSizer1_Items(self.flexGridSizer1)

   254

        self._init_coll_flexGridSizer1_Growables(self.flexGridSizer1)

   255

        self._init_coll_TopSizer_Items(self.TopSizer)

   256

        self._init_coll_TopSizer_Growables(self.TopSizer)

   257

        self._init_coll_GridButtonSizer_Items(self.GridButtonSizer)

   258

   259

        self.SetSizer(self.flexGridSizer1)

   260

   261

    def _init_ctrls(self, prnt):

   262

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

   263

              name='ActionBlockDialog', parent=prnt,

   264

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

   265

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

   266

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

   267

   268

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

   269

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

   270

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

   271

   272

        self.ActionsGrid = CustomGrid(id=ID_ACTIONBLOCKDIALOGVARIABLESGRID,

   273

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

   274

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

   275

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

   276

              'Sans'))

   277

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

   278

              False, 'Sans'))

   279

        self.ActionsGrid.DisableDragGridSize()

   280

        self.ActionsGrid.EnableScrolling(False, True)

   281

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

   282

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

   283

        else:

   284

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

   285

   286

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

   287

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

   288

              size=wx.DefaultSize, style=0)

   289

   290

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

   291

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

   292

              size=wx.DefaultSize, style=0)

   293

   294

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

   295

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

   296

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

   297

   298

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

   299

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

   300

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

   301

   302

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

   303

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

   304

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

   305

        else:

   306

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

   307

   308

        self._init_sizers()

   309

   310

    def __init__(self, parent):

   311

        self._init_ctrls(parent)

   312

   313

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

   314

        typelist = GetTypeList()       

   315

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

   316

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

   317

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

   318

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

   319

   320

        self.ActionsGrid.SetTable(self.Table)

   321

        self.ActionsGrid.SetDefaultValue({"Qualifier" : "N", 

   322

                                          "Duration" : "", 

   323

                                          "Type" : "Action", 

   324

                                          "Value" : "", 

   325

                                          "Indicator" : ""})

   326

        self.ActionsGrid.SetButtons({"Add": self.AddButton,

   327

                                     "Delete": self.DeleteButton,

   328

                                     "Up": self.UpButton,

   329

                                     "Down": self.DownButton})

   330

        self.ActionsGrid.SetRowLabelSize(0)

   331

   332

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

   333

            attr = wx.grid.GridCellAttr()

   334

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

   335

            self.ActionsGrid.SetColAttr(col, attr)

   336

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

   337

            self.ActionsGrid.AutoSizeColumn(col, False)

   338

   339

        self.Table.ResetView(self.ActionsGrid)

   340

        self.ActionsGrid.SetFocus()

   341

        self.ActionsGrid.RefreshButtons()

   342

   343

    def OnOK(self, event):

   344

        self.ActionsGrid.CloseEditControl()

   345

        self.EndModal(wx.ID_OK)

   346

   347

    def OnActionsGridCellChange(self, event):

   348

        wx.CallAfter(self.Table.ResetView, self.ActionsGrid)

   349

        event.Skip()

   350

   351

    def SetQualifierList(self, list):

   352

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

   353

        self.DurationList = list

   354

   355

    def SetVariableList(self, list):

   356

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

   357

   358

    def SetActionList(self, list):

   359

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

   360

   361

    def SetValues(self, actions):

   362

        for action in actions:

   363

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

   364

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

   365

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

   366

                    row["Type"] = "Action"

   367

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

   368

                    row["Type"] = "Variable"

   369

                else:

   370

                    row["Type"] = "Inline"

   371

            else:

   372

                row["Type"] = "Inline"

   373

            if "duration" in action:

   374

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

   375

            else:

   376

                row["Duration"] = ""

   377

            if "indicator" in action:

   378

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

   379

            else:

   380

                row["Indicator"] = ""

   381

            self.Table.AppendRow(row)

   382

        self.Table.ResetView(self.ActionsGrid)

   383

        if len(actions) > 0:

   384

            self.ActionsGrid.SetGridCursor(0, 0)

   385

        self.ActionsGrid.RefreshButtons()

   386

   387

    def GetValues(self):

   388

        values = []

   389

        for data in self.Table.GetData():

   390

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

   391

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

   392

                action["type"] = "reference"

   393

            else:

   394

                action["type"] = "inline"

   395

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

   396

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

   397

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

   398

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

   399

            values.append(action)

   400

        return values