1

#!/usr/bin/env python

     2

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

     3

     6

#

     8

#

    10

#

    15

#

    20

#

    24

    25

import wx

    26

    27

from graphics.GraphicCommons import CONTACT_NORMAL, CONTACT_REVERSE, \

    28

    CONTACT_RISING, CONTACT_FALLING, COIL_NORMAL, COIL_REVERSE, COIL_SET, \

    29

    COIL_RESET, COIL_RISING, COIL_FALLING

    30

from graphics.LD_Objects import LD_Contact, LD_Coil

    31

from BlockPreviewDialog import BlockPreviewDialog

    32

    33

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

    34

#                       Set Ladder Element Parmeters Dialog

    35

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

    36

    37

"""

    38

Class that implements a dialog for defining parameters of a LD contact or coil

    39

graphic element

    40

"""

    41

    42

class LDElementDialog(BlockPreviewDialog):

    43

    44

    def __init__(self, parent, controller, tagname, type):

    45

        """

    46

        Constructor

    47

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

    48

        @param controller: Reference to project controller

    49

        @param tagname: Tagname of project POU edited

    50

        @param type: Type of LD element ('contact or 'coil')

    51

        """

    52

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

    53

              size=wx.Size(350, 320 if type == "contact" else 380),

    54

              title=(_("Edit Contact Values")

    55

                     if type == "contact"

    56

                     else _("Edit Coil Values")))

    57

    58

        # Init common sizers

    59

        self._init_sizers(2, 0, 

    60

              (7 if type == "contact" else 9), None, 2, 1)

    61

    62

        # Create label for LD element modifier

    63

        modifier_label = wx.StaticText(self, label=_('Modifier:'))

    64

        self.LeftGridSizer.AddWindow(modifier_label, border=5, 

    65

              flag=wx.GROW|wx.BOTTOM)

    66

    67

        # Create radio buttons for selecting LD element modifier

    68

        self.ModifierRadioButtons = {}

    69

        first = True

    70

        element_modifiers = ([CONTACT_NORMAL, CONTACT_REVERSE, 

    71

                              CONTACT_RISING, CONTACT_FALLING]

    72

                             if type == "contact"

    73

                             else [COIL_NORMAL, COIL_REVERSE, COIL_SET,

    74

                                   COIL_RESET, COIL_RISING, COIL_FALLING])

    75

        modifiers_label = [_("Normal"), _("Negated")] + \

    76

                          ([_("Set"), _("Reset")] if type == "coil" else []) + \

    77

                          [_("Rising Edge"), _("Falling Edge")]

    78

    79

        for modifier, label in zip(element_modifiers, modifiers_label):

    80

            radio_button = wx.RadioButton(self, label=label, 

    81

                  style=(wx.RB_GROUP if first else 0))

    82

            radio_button.SetValue(first)

    83

            self.Bind(wx.EVT_RADIOBUTTON, self.OnModifierChanged, radio_button)

    84

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

    85

            self.ModifierRadioButtons[modifier] = radio_button

    86

            first = False

    87

    88

        # Create label for LD element variable

    89

        element_variable_label = wx.StaticText(self, label=_('Variable:'))

    90

        self.LeftGridSizer.AddWindow(element_variable_label, border=5,

    91

              flag=wx.GROW|wx.TOP)

    92

    93

        # Create a combo box for defining LD element variable

    94

        self.ElementVariable = wx.ComboBox(self, style=wx.CB_SORT)

    95

        self.Bind(wx.EVT_COMBOBOX, self.OnVariableChanged, 

    96

                  self.ElementVariable)

    97

        self.LeftGridSizer.AddWindow(self.ElementVariable, border=5,

    98

             flag=wx.GROW|wx.TOP)

    99

   100

        # Add preview panel and associated label to sizers

   101

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

   102

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

   103

   104

        # Add buttons sizer to sizers

   105

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

   106

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

   107

   108

        # Save LD element class

   109

        self.ElementClass = (LD_Contact if type == "contact" else LD_Coil)

   110

   111

        # Extract list of variables defined in POU

   112

        self.RefreshVariableList()

   113

   114

        # Set values in ElementVariable

   115

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

   116

            # Only select BOOL variable and avoid input for coil

   117

            if (type == "contact" or var_type != "Input") and \

   118

               value_type == "BOOL":

   119

                self.ElementVariable.Append(name)

   120

   121

        # Normal radio button is default control having keyboard focus

   122

        self.ModifierRadioButtons[element_modifiers[0]].SetFocus()

   123

   124

    def GetElementModifier(self):

   125

        """

   126

        Return modifier selected for LD element

   127

        @return: Modifier selected (None if not found)

   128

        """

   129

        # Go through radio buttons and return modifier associated to the one

   130

        # that is selected

   131

        for modifier, control in self.ModifierRadioButtons.iteritems():

   132

            if control.GetValue():

   133

                return modifier

   134

        return None

   135

   136

    def SetValues(self, values):

   137

        """

   138

        Set default LD element parameters

   139

        @param values: LD element parameters values

   140

        """

   141

        # For each parameters defined, set corresponding control value

   142

        for name, value in values.items():

   143

   144

            # Parameter is LD element variable

   145

            if name == "variable":

   146

                self.ElementVariable.SetValue(value)

   147

   148

            # Set value of other controls

   149

            elif name == "modifier":

   150

                self.ModifierRadioButtons[value].SetValue(True)

   151

   152

        # Refresh preview panel

   153

        self.RefreshPreview()

   154

   155

    def GetValues(self):

   156

        """

   157

        Return LD element parameters defined in dialog

   158

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

   159

        """

   160

        values = {

   161

            "variable": self.ElementVariable.GetValue(),

   162

            "modifier": self.GetElementModifier()}

   163

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

   164

        return values

   165

   166

    def OnModifierChanged(self, event):

   167

        """

   168

        Called when LD element modifier changed

   169

        @param event: wx.RadioButtonEvent

   170

        """

   171

        self.RefreshPreview()

   172

        event.Skip()

   173

   174

    def OnVariableChanged(self, event):

   175

        """

   176

        Called when LD element associated variable changed

   177

        @param event: wx.ComboBoxEvent

   178

        """

   179

        self.RefreshPreview()

   180

        event.Skip()

   181

   182

    def RefreshPreview(self):

   183

        """

   184

        Refresh preview panel of graphic element

   185

        Override BlockPreviewDialog function

   186

        """

   187

        # Set graphic element displayed, creating a LD element

   188

        self.Element = self.ElementClass(

   189

                self.Preview, 

   190

                self.GetElementModifier(),

   191

                self.ElementVariable.GetValue())

   192

   193

        # Call BlockPreviewDialog function

   194

        BlockPreviewDialog.RefreshPreview(self)