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

from __future__ import absolute_import

    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.iteritems()])

    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.iteritems():

   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.iteritems():

   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

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

   159

            self.VariableName.SetStringSelection(selected)

   160

        else:

   161

            self.VariableName.SetSelection(wx.NOT_FOUND)

   162

   163

        # Disable name list box if no name present inside

   164

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

   165

   166

    def SetValues(self, values):

   167

        """

   168

        Set default variable parameters

   169

        @param values: Variable parameters values

   170

        """

   171

   172

        # Get class parameter value

   173

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

   174

        if var_class is not None:

   175

            # Set class selected in class combo box

   176

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

   177

            # Refresh names in name list box according to var class

   178

            self.RefreshNameList()

   179

   180

        # For each parameters defined, set corresponding control value

   181

        for name, value in values.items():

   182

   183

            # Parameter is variable expression

   184

            if name == "expression":

   185

                # Set expression text control value

   186

                self.Expression.ChangeValue(value)

   187

                # Select corresponding text in name list box if it exists

   188

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

   189

                    self.VariableName.SetStringSelection(value)

   190

                else:

   191

                    self.VariableName.SetSelection(wx.NOT_FOUND)

   192

   193

            # Parameter is variable execution order

   194

            elif name == "executionOrder":

   195

                self.ExecutionOrder.SetValue(value)

   196

   197

        # Refresh preview panel

   198

        self.Refresh()

   199

        self.Fit()

   200

   201

    def GetValues(self):

   202

        """

   203

        Return block parameters defined in dialog

   204

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

   205

        """

   206

        expression = self.Expression.GetValue()

   207

        values = {

   208

            "class": self.VARIABLE_CLASSES_DICT_REVERSE[

   209

                self.Class.GetStringSelection()],

   210

            "expression": expression,

   211

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

   212

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

   213

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

   214

        return values

   215

   216

    def OnOK(self, event):

   217

        """

   218

        Called when dialog OK button is pressed

   219

        Test if parameters defined are valid

   220

        @param event: wx.Event from OK button

   221

        """

   222

        message = None

   223

   224

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

   225

        value = self.Expression.GetValue()

   226

        if value == "":

   227

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

   228

   229

        # Show error message if an error is detected

   230

        if message is not None:

   231

            self.ShowErrorMessage(message)

   232

   233

        else:

   234

            # Call BlockPreviewDialog function

   235

            BlockPreviewDialog.OnOK(self, event)

   236

   237

    def OnClassChanged(self, event):

   238

        """

   239

        Called when variable class value changed

   240

        @param event: wx.ComboBoxEvent

   241

        """

   242

        # Refresh name list box values

   243

        self.RefreshNameList()

   244

   245

        self.Refresh()

   246

        event.Skip()

   247

   248

    def OnNameChanged(self, event):

   249

        """

   250

        Called when name selected in name list box changed

   251

        @param event: wx.ListBoxEvent

   252

        """

   253

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

   254

        # list box if value selected is valid

   255

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

   256

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

   257

   258

        self.Refresh()

   259

        event.Skip()

   260

   261

    def OnExpressionChanged(self, event):

   262

        """

   263

        Called when expression text control is changed by user

   264

        @param event: wx.ListBoxEvent

   265

        """

   266

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

   267

        self.VariableName.SetSelection(

   268

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

   269

   270

        self.Refresh()

   271

        event.Skip()

   272

   273

    def OnExecutionOrderChanged(self, event):

   274

        """

   275

        Called when block execution control value changed

   276

        @param event: wx.SpinEvent

   277

        """

   278

        self.Refresh()

   279

        event.Skip()

   280

   281

    def DrawPreview(self):

   282

        """

   283

        Refresh preview panel of graphic element

   284

        Override BlockPreviewDialog function

   285

        """

   286

        # Get expression value to put in FBD variable element

   287

        name = self.Expression.GetValue()

   288

   289

        # Set graphic element displayed, creating a FBD variable element

   290

        self.Element = FBD_Variable(

   291

            self.Preview,

   292

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

   293

            name,

   294

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

   295

            executionOrder=self.ExecutionOrder.GetValue())

   296

   297

        # Call BlockPreviewDialog function

   298

        BlockPreviewDialog.DrawPreview(self)