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

    27

import wx

    28

    29

from graphics.GraphicCommons import INPUT, INOUT, OUTPUT

    30

from graphics.FBD_Objects import FBD_Variable

    31

from dialogs.BlockPreviewDialog import BlockPreviewDialog

    32

    33

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

    34

#                                    Helpers

    35

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

    36

    37

    38

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

    39

#                        Set Variable Parameters Dialog

    40

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

    41

    42

    43

class FBDVariableDialog(BlockPreviewDialog):

    44

    """

    45

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

    46

    element

    47

    """

    48

    49

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

    50

        """

    51

        Constructor

    52

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

    53

        @param controller: Reference to project controller

    54

        @param tagname: Tagname of project POU edited

    55

        @param exclude_input: Exclude input from variable class selection

    56

        """

    57

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

    58

                                    title=_('Variable Properties'))

    59

    60

        # Dictionaries containing correspondence between variable block class and string

    61

        # to be shown in Class combo box in both sense

    62

        self.VARIABLE_CLASSES_DICT = {

    63

            INPUT:  _("Input"),

    64

            INOUT:  _("InOut"),

    65

            OUTPUT: _("Output")

    66

        }

    67

    68

        self.VARIABLE_CLASSES_DICT_REVERSE = dict(

    69

            [(value, key) for key, value in self.VARIABLE_CLASSES_DICT.items()])

    70

    71

        # Init common sizers

    72

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

    73

    74

        # Create label for variable class

    75

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

    76

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

    77

    78

        # Create a combo box for defining variable class

    79

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

    80

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

    81

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

    82

    83

        # Create label for variable execution order

    84

        execution_order_label = wx.StaticText(self,

    85

                                              label=_('Execution Order:'))

    86

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

    87

    88

        # Create spin control for defining variable execution order

    89

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

    90

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

    91

                  self.ExecutionOrder)

    92

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

    93

    94

        # Create label for variable expression

    95

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

    96

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

    97

                                      flag=wx.GROW | wx.BOTTOM)

    98

    99

        # Create text control for defining variable expression

   100

        self.Expression = wx.TextCtrl(self)

   101

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

   102

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

   103

   104

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

   105

        # variables defined in POU

   106

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

   107

                                       style=wx.LB_SINGLE | wx.LB_SORT)

   108

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

   109

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

   110

   111

        # Add preview panel and associated label to sizers

   112

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

   113

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

   114

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

   115

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

   116

   117

        # Add buttons sizer to sizers

   118

        self.MainSizer.Add(

   119

            self.ButtonSizer, border=20,

   120

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

   121

   122

        # Set options that can be selected in class combo box

   123

        for var_class, choice in self.VARIABLE_CLASSES_DICT.items():

   124

            if not exclude_input or var_class != INPUT:

   125

                self.Class.Append(choice)

   126

        self.Class.SetSelection(0)

   127

   128

        # Extract list of variables defined in POU

   129

        self.RefreshVariableList()

   130

   131

        # Refresh values in name list box

   132

        self.RefreshNameList()

   133

   134

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

   135

        self.Fit()

   136

   137

        # Class combo box is default control having keyboard focus

   138

        self.Class.SetFocus()

   139

   140

    def RefreshNameList(self):

   141

        """

   142

        Called to refresh names in name list box

   143

        """

   144

        # Get variable class to select POU variable applicable

   145

        var_class = self.VARIABLE_CLASSES_DICT_REVERSE[

   146

            self.Class.GetStringSelection()]

   147

   148

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

   149

        # list that can be applied to variable class

   150

        self.VariableName.Clear()

   151

        for name, (var_type, _value_type) in self.VariableList.items():

   152

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

   153

                self.VariableName.Append(name)

   154

   155

        # Get variable expression and select corresponding value in name list

   156

        # box if it exists

   157

        selected = self.Expression.GetValue()

   158

        self.VariableName.SetSelection(

   159

            wx.NOT_FOUND if selected == "" else self.VariableName.FindString(selected, True))

   160

   161

        # Disable name list box if no name present inside

   162

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

   163

   164

    def SetValues(self, values):

   165

        """

   166

        Set default variable parameters

   167

        @param values: Variable parameters values

   168

        """

   169

   170

        # Get class parameter value

   171

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

   172

        if var_class is not None:

   173

            # Set class selected in class combo box

   174

            self.Class.SetStringSelection(self.VARIABLE_CLASSES_DICT[var_class])

   175

            # Refresh names in name list box according to var class

   176

            self.RefreshNameList()

   177

   178

        # For each parameters defined, set corresponding control value

   179

        for name, value in list(values.items()):

   180

   181

            # Parameter is variable expression

   182

            if name == "expression":

   183

                # Set expression text control value

   184

                self.Expression.ChangeValue(value)

   185

                # Select corresponding text in name list box if it exists

   186

                self.VariableName.SetSelection(self.VariableName.FindString(value, True))

   187

   188

            # Parameter is variable execution order

   189

            elif name == "executionOrder":

   190

                self.ExecutionOrder.SetValue(value)

   191

   192

        # Refresh preview panel

   193

        self.Refresh()

   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": self.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.Refresh()

   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.Refresh()

   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(), True))

   264

   265

        self.Refresh()

   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.Refresh()

   274

        event.Skip()

   275

   276

    def DrawPreview(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(

   286

            self.Preview,

   287

            self.VARIABLE_CLASSES_DICT_REVERSE[self.Class.GetStringSelection()],

   288

            name,

   289

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

   290

            executionOrder=self.ExecutionOrder.GetValue())

   291

   292

        # Call BlockPreviewDialog function

   293

        BlockPreviewDialog.DrawPreview(self)