1

#!/usr/bin/env python

     2

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

     3

     4

# This file is part of Beremiz, a Integrated Development Environment for

     5

# programming IEC 61131-3 automates supporting plcopen standard and CanFestival.

     6

#

     7

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

     8

# Copyright (C) 2017: Andrey Skvortsov <andrej.skvortzov@gmail.com>

     9

#

    10

# See COPYING file for copyrights details.

    11

#

    12

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

    13

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

    14

# as published by the Free Software Foundation; either version 2

    15

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

    16

#

    17

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

    18

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

    19

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    20

# GNU General Public License for more details.

    21

#

    22

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

    23

# along with this program; if not, write to the Free Software

    24

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    25

    26

import wx

    27

    28

from graphics.GraphicCommons import INPUT, INOUT, OUTPUT

    29

from graphics.FBD_Objects import FBD_Variable

    30

from BlockPreviewDialog import BlockPreviewDialog

    31

    32

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

    33

#                                    Helpers

    34

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

    35

    36

# Dictionaries containing correspondence between variable block class and string

    37

# to be shown in Class combo box in both sense

    38

VARIABLE_CLASSES_DICT = {INPUT : _("Input"),

    39

                         INOUT : _("InOut"),

    40

                         OUTPUT : _("Output")}

    41

VARIABLE_CLASSES_DICT_REVERSE = dict(

    42

    [(value, key) for key, value in VARIABLE_CLASSES_DICT.iteritems()])

    43

    44

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

    45

#                        Set Variable Parameters Dialog

    46

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

    47

    48

    49

class FBDVariableDialog(BlockPreviewDialog):

    50

    """

    51

    Class that implements a dialog for defining parameters of a FBD variable graphic

    52

    element

    53

    """

    54

    55

    def __init__(self, parent, controller, tagname, exclude_input=False):

    56

        """

    57

        Constructor

    58

        @param parent: Parent wx.Window of dialog for modal

    59

        @param controller: Reference to project controller

    60

        @param tagname: Tagname of project POU edited

    61

        @param exclude_input: Exclude input from variable class selection

    62

        """

    63

        BlockPreviewDialog.__init__(self, parent, controller, tagname,

    64

              title=_('Variable Properties'))

    65

    66

        # Init common sizers

    67

        self._init_sizers(4, 2, 4, None, 3, 2)

    68

    69

        # Create label for variable class

    70

        class_label = wx.StaticText(self, label=_('Class:'))

    71

        self.LeftGridSizer.AddWindow(class_label, flag=wx.GROW)

    72

    73

        # Create a combo box for defining variable class

    74

        self.Class = wx.ComboBox(self, style=wx.CB_READONLY)

    75

        self.Bind(wx.EVT_COMBOBOX, self.OnClassChanged, self.Class)

    76

        self.LeftGridSizer.AddWindow(self.Class, flag=wx.GROW)

    77

    78

        # Create label for variable execution order

    79

        execution_order_label = wx.StaticText(self,

    80

              label=_('Execution Order:'))

    81

        self.LeftGridSizer.AddWindow(execution_order_label, flag=wx.GROW)

    82

    83

        # Create spin control for defining variable execution order

    84

        self.ExecutionOrder = wx.SpinCtrl(self, min=0, style=wx.SP_ARROW_KEYS)

    85

        self.Bind(wx.EVT_SPINCTRL, self.OnExecutionOrderChanged,

    86

                  self.ExecutionOrder)

    87

        self.LeftGridSizer.AddWindow(self.ExecutionOrder, flag=wx.GROW)

    88

    89

        # Create label for variable expression

    90

        name_label = wx.StaticText(self, label=_('Expression:'))

    91

        self.RightGridSizer.AddWindow(name_label, border=5,

    92

              flag=wx.GROW|wx.BOTTOM)

    93

    94

        # Create text control for defining variable expression

    95

        self.Expression = wx.TextCtrl(self)

    96

        self.Bind(wx.EVT_TEXT, self.OnExpressionChanged, self.Expression)

    97

        self.RightGridSizer.AddWindow(self.Expression, flag=wx.GROW)

    98

    99

        # Create a list box to selected variable expression in the list of

   100

        # variables defined in POU

   101

        self.VariableName = wx.ListBox(self, size=wx.Size(-1,120),

   102

              style=wx.LB_SINGLE|wx.LB_SORT)

   103

        self.Bind(wx.EVT_LISTBOX, self.OnNameChanged, self.VariableName)

   104

        self.RightGridSizer.AddWindow(self.VariableName, border=4, flag=wx.GROW|wx.TOP)

   105

   106

        # Add preview panel and associated label to sizers

   107

        self.MainSizer.AddWindow(self.PreviewLabel, border=20,

   108

              flag=wx.GROW|wx.LEFT|wx.RIGHT)

   109

        self.MainSizer.AddWindow(self.Preview, border=20,

   110

              flag=wx.GROW|wx.LEFT|wx.RIGHT)

   111

   112

        # Add buttons sizer to sizers

   113

        self.MainSizer.AddSizer(self.ButtonSizer, border=20,

   114

              flag=wx.ALIGN_RIGHT|wx.BOTTOM|wx.LEFT|wx.RIGHT)

   115

   116

        # Set options that can be selected in class combo box

   117

        for var_class, choice in VARIABLE_CLASSES_DICT.iteritems():

   118

            if not exclude_input or var_class != INPUT:

   119

                self.Class.Append(choice)

   120

        self.Class.SetSelection(0)

   121

   122

        # Extract list of variables defined in POU

   123

        self.RefreshVariableList()

   124

   125

        # Refresh values in name list box

   126

        self.RefreshNameList()

   127

   128

        self.Preview.SetInitialSize(wx.Size(-1, 60))

   129

        self.Fit()

   130

   131

        # Class combo box is default control having keyboard focus

   132

        self.Class.SetFocus()

   133

   134

    def RefreshNameList(self):

   135

        """

   136

        Called to refresh names in name list box

   137

        """

   138

        # Get variable class to select POU variable applicable

   139

        var_class = VARIABLE_CLASSES_DICT_REVERSE[

   140

                            self.Class.GetStringSelection()]

   141

   142

        # Refresh names in name list box by selecting variables in POU variables

   143

        # list that can be applied to variable class

   144

        self.VariableName.Clear()

   145

        for name, (var_type, value_type) in self.VariableList.iteritems():

   146

            if var_type != "Input" or var_class == INPUT:

   147

                self.VariableName.Append(name)

   148

   149

        # Get variable expression and select corresponding value in name list

   150

        # box if it exists

   151

        selected = self.Expression.GetValue()

   152

        if (selected != "" and

   153

            self.VariableName.FindString(selected) != wx.NOT_FOUND):

   154

            self.VariableName.SetStringSelection(selected)

   155

        else:

   156

            self.VariableName.SetSelection(wx.NOT_FOUND)

   157

   158

        # Disable name list box if no name present inside

   159

        self.VariableName.Enable(self.VariableName.GetCount() > 0)

   160

   161

    def SetValues(self, values):

   162

        """

   163

        Set default variable parameters

   164

        @param values: Variable parameters values

   165

        """

   166

   167

        # Get class parameter value

   168

        var_class = values.get("class", None)

   169

        if var_class is not None:

   170

            # Set class selected in class combo box

   171

            self.Class.SetStringSelection(VARIABLE_CLASSES_DICT[var_class])

   172

            # Refresh names in name list box according to var class

   173

            self.RefreshNameList()

   174

   175

        # For each parameters defined, set corresponding control value

   176

        for name, value in values.items():

   177

   178

            # Parameter is variable expression

   179

            if name == "expression":

   180

                # Set expression text control value

   181

                self.Expression.ChangeValue(value)

   182

                # Select corresponding text in name list box if it exists

   183

                if self.VariableName.FindString(value) != wx.NOT_FOUND:

   184

                    self.VariableName.SetStringSelection(value)

   185

                else:

   186

                    self.VariableName.SetSelection(wx.NOT_FOUND)

   187

   188

            # Parameter is variable execution order

   189

            elif name == "executionOrder":

   190

                self.ExecutionOrder.SetValue(value)

   191

   192

        # Refresh preview panel

   193

        self.RefreshPreview()

   194

        self.Fit()

   195

   196

    def GetValues(self):

   197

        """

   198

        Return block parameters defined in dialog

   199

        @return: {parameter_name: parameter_value,...}

   200

        """

   201

        expression = self.Expression.GetValue()

   202

        values = {

   203

            "class": VARIABLE_CLASSES_DICT_REVERSE[

   204

                        self.Class.GetStringSelection()],

   205

            "expression": expression,

   206

            "var_type": self.VariableList.get(expression, (None, None))[1],

   207

            "executionOrder": self.ExecutionOrder.GetValue()}

   208

        values["width"], values["height"] = self.Element.GetSize()

   209

        return values

   210

   211

    def OnOK(self, event):

   212

        """

   213

        Called when dialog OK button is pressed

   214

        Test if parameters defined are valid

   215

        @param event: wx.Event from OK button

   216

        """

   217

        message = None

   218

   219

        # Test that an expression have been selected or typed by user

   220

        value = self.Expression.GetValue()

   221

        if value == "":

   222

            message = _("At least a variable or an expression must be selected!")

   223

   224

        # Show error message if an error is detected

   225

        if message is not None:

   226

            self.ShowErrorMessage(message)

   227

   228

        else:

   229

            # Call BlockPreviewDialog function

   230

            BlockPreviewDialog.OnOK(self, event)

   231

   232

    def OnClassChanged(self, event):

   233

        """

   234

        Called when variable class value changed

   235

        @param event: wx.ComboBoxEvent

   236

        """

   237

        # Refresh name list box values

   238

        self.RefreshNameList()

   239

   240

        self.RefreshPreview()

   241

        event.Skip()

   242

   243

    def OnNameChanged(self, event):

   244

        """

   245

        Called when name selected in name list box changed

   246

        @param event: wx.ListBoxEvent

   247

        """

   248

        # Change expression test control value to the value selected in name

   249

        # list box if value selected is valid

   250

        if self.VariableName.GetSelection() != wx.NOT_FOUND:

   251

            self.Expression.ChangeValue(self.VariableName.GetStringSelection())

   252

   253

        self.RefreshPreview()

   254

        event.Skip()

   255

   256

    def OnExpressionChanged(self, event):

   257

        """

   258

        Called when expression text control is changed by user

   259

        @param event: wx.ListBoxEvent

   260

        """

   261

        # Select the corresponding value in name list box if it exists

   262

        self.VariableName.SetSelection(

   263

            self.VariableName.FindString(self.Expression.GetValue()))

   264

   265

        self.RefreshPreview()

   266

        event.Skip()

   267

   268

    def OnExecutionOrderChanged(self, event):

   269

        """

   270

        Called when block execution control value changed

   271

        @param event: wx.SpinEvent

   272

        """

   273

        self.RefreshPreview()

   274

        event.Skip()

   275

   276

    def RefreshPreview(self):

   277

        """

   278

        Refresh preview panel of graphic element

   279

        Override BlockPreviewDialog function

   280

        """

   281

        # Get expression value to put in FBD variable element

   282

        name = self.Expression.GetValue()

   283

   284

        # Set graphic element displayed, creating a FBD variable element

   285

        self.Element = FBD_Variable(self.Preview,

   286

                    VARIABLE_CLASSES_DICT_REVERSE[

   287

                        self.Class.GetStringSelection()],

   288

                    name,

   289

                    self.VariableList.get(name, ("", ""))[1],

   290

                    executionOrder = self.ExecutionOrder.GetValue())

   291

   292

        # Call BlockPreviewDialog function

   293

        BlockPreviewDialog.RefreshPreview(self)