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

# Dictionaries containing correspondence between variable block class and string

    38

# to be shown in Class combo box in both sense

    39

VARIABLE_CLASSES_DICT = {

    40

    INPUT:  _("Input"),

    41

    INOUT:  _("InOut"),

    42

    OUTPUT: _("Output")

    43

}

    44

    45

VARIABLE_CLASSES_DICT_REVERSE = dict(

    46

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

    47

    48

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

    49

#                        Set Variable Parameters Dialog

    50

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

    51

    52

    53

class FBDVariableDialog(BlockPreviewDialog):

    54

    """

    55

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

    56

    element

    57

    """

    58

    59

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

    60

        """

    61

        Constructor

    62

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

    63

        @param controller: Reference to project controller

    64

        @param tagname: Tagname of project POU edited

    65

        @param exclude_input: Exclude input from variable class selection

    66

        """

    67

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

    68

                                    title=_('Variable Properties'))

    69

    70

        # Init common sizers

    71

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

    72

    73

        # Create label for variable class

    74

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

    75

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

    76

    77

        # Create a combo box for defining variable class

    78

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

    79

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

    80

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

    81

    82

        # Create label for variable execution order

    83

        execution_order_label = wx.StaticText(self,

    84

                                              label=_('Execution Order:'))

    85

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

    86

    87

        # Create spin control for defining variable execution order

    88

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

    89

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

    90

                  self.ExecutionOrder)

    91

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

    92

    93

        # Create label for variable expression

    94

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

    95

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

    96

                                      flag=wx.GROW | wx.BOTTOM)

    97

    98

        # Create text control for defining variable expression

    99

        self.Expression = wx.TextCtrl(self)

   100

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

   101

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

   102

   103

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

   104

        # variables defined in POU

   105

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

   106

                                       style=wx.LB_SINGLE | wx.LB_SORT)

   107

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

   108

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

   109

   110

        # Add preview panel and associated label to sizers

   111

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

   112

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

   113

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

   114

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

   115

   116

        # Add buttons sizer to sizers

   117

        self.MainSizer.AddSizer(

   118

            self.ButtonSizer, border=20,

   119

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

   120

   121

        # Set options that can be selected in class combo box

   122

        for var_class, choice in VARIABLE_CLASSES_DICT.iteritems():

   123

            if not exclude_input or var_class != INPUT:

   124

                self.Class.Append(choice)

   125

        self.Class.SetSelection(0)

   126

   127

        # Extract list of variables defined in POU

   128

        self.RefreshVariableList()

   129

   130

        # Refresh values in name list box

   131

        self.RefreshNameList()

   132

   133

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

   134

        self.Fit()

   135

   136

        # Class combo box is default control having keyboard focus

   137

        self.Class.SetFocus()

   138

   139

    def RefreshNameList(self):

   140

        """

   141

        Called to refresh names in name list box

   142

        """

   143

        # Get variable class to select POU variable applicable

   144

        var_class = VARIABLE_CLASSES_DICT_REVERSE[

   145

                            self.Class.GetStringSelection()]

   146

   147

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

   148

        # list that can be applied to variable class

   149

        self.VariableName.Clear()

   150

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

   151

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

   152

                self.VariableName.Append(name)

   153

   154

        # Get variable expression and select corresponding value in name list

   155

        # box if it exists

   156

        selected = self.Expression.GetValue()

   157

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

   158

            self.VariableName.SetStringSelection(selected)

   159

        else:

   160

            self.VariableName.SetSelection(wx.NOT_FOUND)

   161

   162

        # Disable name list box if no name present inside

   163

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

   164

   165

    def SetValues(self, values):

   166

        """

   167

        Set default variable parameters

   168

        @param values: Variable parameters values

   169

        """

   170

   171

        # Get class parameter value

   172

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

   173

        if var_class is not None:

   174

            # Set class selected in class combo box

   175

            self.Class.SetStringSelection(VARIABLE_CLASSES_DICT[var_class])

   176

            # Refresh names in name list box according to var class

   177

            self.RefreshNameList()

   178

   179

        # For each parameters defined, set corresponding control value

   180

        for name, value in values.items():

   181

   182

            # Parameter is variable expression

   183

            if name == "expression":

   184

                # Set expression text control value

   185

                self.Expression.ChangeValue(value)

   186

                # Select corresponding text in name list box if it exists

   187

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

   188

                    self.VariableName.SetStringSelection(value)

   189

                else:

   190

                    self.VariableName.SetSelection(wx.NOT_FOUND)

   191

   192

            # Parameter is variable execution order

   193

            elif name == "executionOrder":

   194

                self.ExecutionOrder.SetValue(value)

   195

   196

        # Refresh preview panel

   197

        self.RefreshPreview()

   198

        self.Fit()

   199

   200

    def GetValues(self):

   201

        """

   202

        Return block parameters defined in dialog

   203

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

   204

        """

   205

        expression = self.Expression.GetValue()

   206

        values = {

   207

            "class": VARIABLE_CLASSES_DICT_REVERSE[

   208

                        self.Class.GetStringSelection()],

   209

            "expression": expression,

   210

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

   211

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

   212

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

   213

        return values

   214

   215

    def OnOK(self, event):

   216

        """

   217

        Called when dialog OK button is pressed

   218

        Test if parameters defined are valid

   219

        @param event: wx.Event from OK button

   220

        """

   221

        message = None

   222

   223

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

   224

        value = self.Expression.GetValue()

   225

        if value == "":

   226

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

   227

   228

        # Show error message if an error is detected

   229

        if message is not None:

   230

            self.ShowErrorMessage(message)

   231

   232

        else:

   233

            # Call BlockPreviewDialog function

   234

            BlockPreviewDialog.OnOK(self, event)

   235

   236

    def OnClassChanged(self, event):

   237

        """

   238

        Called when variable class value changed

   239

        @param event: wx.ComboBoxEvent

   240

        """

   241

        # Refresh name list box values

   242

        self.RefreshNameList()

   243

   244

        self.RefreshPreview()

   245

        event.Skip()

   246

   247

    def OnNameChanged(self, event):

   248

        """

   249

        Called when name selected in name list box changed

   250

        @param event: wx.ListBoxEvent

   251

        """

   252

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

   253

        # list box if value selected is valid

   254

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

   255

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

   256

   257

        self.RefreshPreview()

   258

        event.Skip()

   259

   260

    def OnExpressionChanged(self, event):

   261

        """

   262

        Called when expression text control is changed by user

   263

        @param event: wx.ListBoxEvent

   264

        """

   265

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

   266

        self.VariableName.SetSelection(

   267

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

   268

   269

        self.RefreshPreview()

   270

        event.Skip()

   271

   272

    def OnExecutionOrderChanged(self, event):

   273

        """

   274

        Called when block execution control value changed

   275

        @param event: wx.SpinEvent

   276

        """

   277

        self.RefreshPreview()

   278

        event.Skip()

   279

   280

    def RefreshPreview(self):

   281

        """

   282

        Refresh preview panel of graphic element

   283

        Override BlockPreviewDialog function

   284

        """

   285

        # Get expression value to put in FBD variable element

   286

        name = self.Expression.GetValue()

   287

   288

        # Set graphic element displayed, creating a FBD variable element

   289

        self.Element = FBD_Variable(

   290

            self.Preview,

   291

            VARIABLE_CLASSES_DICT_REVERSE[self.Class.GetStringSelection()],

   292

            name,

   293

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

   294

            executionOrder=self.ExecutionOrder.GetValue())

   295

   296

        # Call BlockPreviewDialog function

   297

        BlockPreviewDialog.RefreshPreview(self)