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 = {

    39

    INPUT:  _("Input"),

    40

    INOUT:  _("InOut"),

    41

    OUTPUT: _("Output")

    42

}

    43

    44

VARIABLE_CLASSES_DICT_REVERSE = dict(

    45

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

    46

    47

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

    48

#                        Set Variable Parameters Dialog

    49

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

    50

    51

    52

class FBDVariableDialog(BlockPreviewDialog):

    53

    """

    54

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

    55

    element

    56

    """

    57

    58

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

    59

        """

    60

        Constructor

    61

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

    62

        @param controller: Reference to project controller

    63

        @param tagname: Tagname of project POU edited

    64

        @param exclude_input: Exclude input from variable class selection

    65

        """

    66

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

    67

                                    title=_('Variable Properties'))

    68

    69

        # Init common sizers

    70

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

    71

    72

        # Create label for variable class

    73

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

    74

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

    75

    76

        # Create a combo box for defining variable class

    77

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

    78

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

    79

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

    80

    81

        # Create label for variable execution order

    82

        execution_order_label = wx.StaticText(self,

    83

                                              label=_('Execution Order:'))

    84

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

    85

    86

        # Create spin control for defining variable execution order

    87

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

    88

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

    89

                  self.ExecutionOrder)

    90

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

    91

    92

        # Create label for variable expression

    93

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

    94

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

    95

                                      flag=wx.GROW | wx.BOTTOM)

    96

    97

        # Create text control for defining variable expression

    98

        self.Expression = wx.TextCtrl(self)

    99

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

   100

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

   101

   102

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

   103

        # variables defined in POU

   104

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

   105

                                       style=wx.LB_SINGLE | wx.LB_SORT)

   106

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

   107

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

   108

   109

        # Add preview panel and associated label to sizers

   110

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

   111

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

   112

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

   113

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

   114

   115

        # Add buttons sizer to sizers

   116

        self.MainSizer.AddSizer(

   117

            self.ButtonSizer, border=20,

   118

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

   119

   120

        # Set options that can be selected in class combo box

   121

        for var_class, choice in VARIABLE_CLASSES_DICT.iteritems():

   122

            if not exclude_input or var_class != INPUT:

   123

                self.Class.Append(choice)

   124

        self.Class.SetSelection(0)

   125

   126

        # Extract list of variables defined in POU

   127

        self.RefreshVariableList()

   128

   129

        # Refresh values in name list box

   130

        self.RefreshNameList()

   131

   132

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

   133

        self.Fit()

   134

   135

        # Class combo box is default control having keyboard focus

   136

        self.Class.SetFocus()

   137

   138

    def RefreshNameList(self):

   139

        """

   140

        Called to refresh names in name list box

   141

        """

   142

        # Get variable class to select POU variable applicable

   143

        var_class = VARIABLE_CLASSES_DICT_REVERSE[

   144

                            self.Class.GetStringSelection()]

   145

   146

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

   147

        # list that can be applied to variable class

   148

        self.VariableName.Clear()

   149

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

   150

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

   151

                self.VariableName.Append(name)

   152

   153

        # Get variable expression and select corresponding value in name list

   154

        # box if it exists

   155

        selected = self.Expression.GetValue()

   156

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

   157

            self.VariableName.SetStringSelection(selected)

   158

        else:

   159

            self.VariableName.SetSelection(wx.NOT_FOUND)

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

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

   187

                    self.VariableName.SetStringSelection(value)

   188

                else:

   189

                    self.VariableName.SetSelection(wx.NOT_FOUND)

   190

   191

            # Parameter is variable execution order

   192

            elif name == "executionOrder":

   193

                self.ExecutionOrder.SetValue(value)

   194

   195

        # Refresh preview panel

   196

        self.RefreshPreview()

   197

        self.Fit()

   198

   199

    def GetValues(self):

   200

        """

   201

        Return block parameters defined in dialog

   202

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

   203

        """

   204

        expression = self.Expression.GetValue()

   205

        values = {

   206

            "class": VARIABLE_CLASSES_DICT_REVERSE[

   207

                        self.Class.GetStringSelection()],

   208

            "expression": expression,

   209

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

   210

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

   211

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

   212

        return values

   213

   214

    def OnOK(self, event):

   215

        """

   216

        Called when dialog OK button is pressed

   217

        Test if parameters defined are valid

   218

        @param event: wx.Event from OK button

   219

        """

   220

        message = None

   221

   222

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

   223

        value = self.Expression.GetValue()

   224

        if value == "":

   225

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

   226

   227

        # Show error message if an error is detected

   228

        if message is not None:

   229

            self.ShowErrorMessage(message)

   230

   231

        else:

   232

            # Call BlockPreviewDialog function

   233

            BlockPreviewDialog.OnOK(self, event)

   234

   235

    def OnClassChanged(self, event):

   236

        """

   237

        Called when variable class value changed

   238

        @param event: wx.ComboBoxEvent

   239

        """

   240

        # Refresh name list box values

   241

        self.RefreshNameList()

   242

   243

        self.RefreshPreview()

   244

        event.Skip()

   245

   246

    def OnNameChanged(self, event):

   247

        """

   248

        Called when name selected in name list box changed

   249

        @param event: wx.ListBoxEvent

   250

        """

   251

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

   252

        # list box if value selected is valid

   253

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

   254

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

   255

   256

        self.RefreshPreview()

   257

        event.Skip()

   258

   259

    def OnExpressionChanged(self, event):

   260

        """

   261

        Called when expression text control is changed by user

   262

        @param event: wx.ListBoxEvent

   263

        """

   264

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

   265

        self.VariableName.SetSelection(

   266

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

   267

   268

        self.RefreshPreview()

   269

        event.Skip()

   270

   271

    def OnExecutionOrderChanged(self, event):

   272

        """

   273

        Called when block execution control value changed

   274

        @param event: wx.SpinEvent

   275

        """

   276

        self.RefreshPreview()

   277

        event.Skip()

   278

   279

    def RefreshPreview(self):

   280

        """

   281

        Refresh preview panel of graphic element

   282

        Override BlockPreviewDialog function

   283

        """

   284

        # Get expression value to put in FBD variable element

   285

        name = self.Expression.GetValue()

   286

   287

        # Set graphic element displayed, creating a FBD variable element

   288

        self.Element = FBD_Variable(

   289

            self.Preview,

   290

            VARIABLE_CLASSES_DICT_REVERSE[self.Class.GetStringSelection()],

   291

            name,

   292

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

   293

            executionOrder=self.ExecutionOrder.GetValue())

   294

   295

        # Call BlockPreviewDialog function

   296

        BlockPreviewDialog.RefreshPreview(self)