1

     2

import os

     3

import types

     4

     5

import wx

     6

import wx.lib.buttons

     7

     8

from EditorPanel import EditorPanel

     9

    10

from IDEFrame import TITLE, FILEMENU, PROJECTTREE, PAGETITLES

    11

    12

from controls import TextCtrlAutoComplete

    13

from dialogs import BrowseValuesLibraryDialog

    14

from util.BitmapLibrary import GetBitmap

    15

    16

if wx.Platform == '__WXMSW__':

    17

    faces = { 'times': 'Times New Roman',

    18

              'mono' : 'Courier New',

    19

              'helv' : 'Arial',

    20

              'other': 'Comic Sans MS',

    21

              'size' : 16,

    22

             }

    23

else:

    24

    faces = { 'times': 'Times',

    25

              'mono' : 'Courier',

    26

              'helv' : 'Helvetica',

    27

              'other': 'new century schoolbook',

    28

              'size' : 18,

    29

             }

    30

    31

SCROLLBAR_UNIT = 10

    32

WINDOW_COLOUR = wx.Colour(240, 240, 240)

    33

    34

CWD = os.path.split(os.path.realpath(__file__))[0]

    35

    36

def Bpath(*args):

    37

    return os.path.join(CWD,*args)

    38

    39

# Some helpers to tweak GenBitmapTextButtons

    40

# TODO: declare customized classes instead.

    41

gen_mini_GetBackgroundBrush = lambda obj:lambda dc: wx.Brush(obj.GetParent().GetBackgroundColour(), wx.SOLID)

    42

gen_textbutton_GetLabelSize = lambda obj:lambda:(wx.lib.buttons.GenButton._GetLabelSize(obj)[:-1] + (False,))

    43

    44

def make_genbitmaptogglebutton_flat(button):

    45

    button.GetBackgroundBrush = gen_mini_GetBackgroundBrush(button)

    46

    button.labelDelta = 0

    47

    button.SetBezelWidth(0)

    48

    button.SetUseFocusIndicator(False)

    49

    50

# Patch wx.lib.imageutils so that gray is supported on alpha images

    51

import wx.lib.imageutils

    52

from wx.lib.imageutils import grayOut as old_grayOut

    53

def grayOut(anImage):

    54

    if anImage.HasAlpha():

    55

        AlphaData = anImage.GetAlphaData()

    56

    else :

    57

        AlphaData = None

    58

    59

    old_grayOut(anImage)

    60

    61

    if AlphaData is not None:

    62

        anImage.SetAlphaData(AlphaData)

    63

    64

wx.lib.imageutils.grayOut = grayOut

    65

    66

class GenBitmapTextButton(wx.lib.buttons.GenBitmapTextButton):

    67

    def _GetLabelSize(self):

    68

        """ used internally """

    69

        w, h = self.GetTextExtent(self.GetLabel())

    70

        if not self.bmpLabel:

    71

            return w, h, False       # if there isn't a bitmap use the size of the text

    72

    73

        w_bmp = self.bmpLabel.GetWidth()+2

    74

        h_bmp = self.bmpLabel.GetHeight()+2

    75

        height = h + h_bmp

    76

        if w_bmp > w:

    77

            width = w_bmp

    78

        else:

    79

            width = w

    80

        return width, height, False

    81

    82

    def DrawLabel(self, dc, width, height, dw=0, dy=0):

    83

        bmp = self.bmpLabel

    84

        if bmp != None:     # if the bitmap is used

    85

            if self.bmpDisabled and not self.IsEnabled():

    86

                bmp = self.bmpDisabled

    87

            if self.bmpFocus and self.hasFocus:

    88

                bmp = self.bmpFocus

    89

            if self.bmpSelected and not self.up:

    90

                bmp = self.bmpSelected

    91

            bw,bh = bmp.GetWidth(), bmp.GetHeight()

    92

            if not self.up:

    93

                dw = dy = self.labelDelta

    94

            hasMask = bmp.GetMask() != None

    95

        else:

    96

            bw = bh = 0     # no bitmap -> size is zero

    97

    98

        dc.SetFont(self.GetFont())

    99

        if self.IsEnabled():

   100

            dc.SetTextForeground(self.GetForegroundColour())

   101

        else:

   102

            dc.SetTextForeground(wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))

   103

   104

        label = self.GetLabel()

   105

        tw, th = dc.GetTextExtent(label)        # size of text

   106

        if not self.up:

   107

            dw = dy = self.labelDelta

   108

   109

        pos_x = (width-bw)/2+dw      # adjust for bitmap and text to centre

   110

        pos_y = (height-bh-th)/2+dy

   111

        if bmp !=None:

   112

            dc.DrawBitmap(bmp, pos_x, pos_y, hasMask) # draw bitmap if available

   113

            pos_x = (width-tw)/2+dw      # adjust for bitmap and text to centre

   114

            pos_y += bh + 2

   115

   116

        dc.DrawText(label, pos_x, pos_y)      # draw the text

   117

   118

   119

class GenStaticBitmap(wx.lib.statbmp.GenStaticBitmap):

   120

    """ Customized GenStaticBitmap, fix transparency redraw bug on wx2.8/win32, 

   121

    and accept image name as __init__ parameter, fail silently if file do not exist"""

   122

    def __init__(self, parent, ID, bitmapname,

   123

                 pos = wx.DefaultPosition, size = wx.DefaultSize,

   124

                 style = 0,

   125

                 name = "genstatbmp"):

   126

   127

        wx.lib.statbmp.GenStaticBitmap.__init__(self, parent, ID, 

   128

                 GetBitmap(bitmapname),

   129

                 pos, size,

   130

                 style,

   131

                 name)

   132

   133

    def OnPaint(self, event):

   134

        dc = wx.PaintDC(self)

   135

        colour = self.GetParent().GetBackgroundColour()

   136

        dc.SetPen(wx.Pen(colour))

   137

        dc.SetBrush(wx.Brush(colour ))

   138

        dc.DrawRectangle(0, 0, *dc.GetSizeTuple())

   139

        if self._bitmap:

   140

            dc.DrawBitmap(self._bitmap, 0, 0, True)

   141

   142

class ConfTreeNodeEditor(EditorPanel):

   143

   144

    SHOW_BASE_PARAMS = True

   145

    SHOW_PARAMS = True

   146

    CONFNODEEDITOR_TABS = []

   147

   148

    def _init_Editor(self, parent):

   149

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   150

        if self.SHOW_PARAMS:

   151

            tabs_num += 1

   152

   153

        if tabs_num > 1:

   154

            self.Editor = wx.Panel(parent, 

   155

                style=wx.SUNKEN_BORDER|wx.SP_3D)

   156

   157

            main_sizer = wx.BoxSizer(wx.VERTICAL)

   158

   159

            self.ConfNodeNoteBook = wx.Notebook(self.Editor)

   160

            parent = self.ConfNodeNoteBook

   161

            main_sizer.AddWindow(self.ConfNodeNoteBook, 1, flag=wx.GROW)

   162

   163

            self.Editor.SetSizer(main_sizer)

   164

        else:

   165

            self.ConfNodeNoteBook = None

   166

            self.Editor = None

   167

   168

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   169

            editor = getattr(self, create_func_name)(parent)

   170

            if self.ConfNodeNoteBook is not None:

   171

                self.ConfNodeNoteBook.AddPage(editor, title)

   172

            else:

   173

                self.Editor = editor

   174

   175

        if self.SHOW_PARAMS:

   176

   177

            panel_style = wx.TAB_TRAVERSAL|wx.HSCROLL|wx.VSCROLL

   178

            if self.ConfNodeNoteBook is None:

   179

                panel_style |= wx.SUNKEN_BORDER

   180

            self.ParamsEditor = wx.ScrolledWindow(parent, 

   181

                  style=panel_style)

   182

            self.ParamsEditor.SetBackgroundColour(WINDOW_COLOUR)

   183

            self.ParamsEditor.Bind(wx.EVT_SIZE, self.OnWindowResize)

   184

            self.ParamsEditor.Bind(wx.EVT_MOUSEWHEEL, self.OnMouseWheel)

   185

   186

            # Variable allowing disabling of ParamsEditor scroll when Popup shown 

   187

            self.ScrollingEnabled = True

   188

   189

            if self.SHOW_BASE_PARAMS:

   190

                self.ParamsEditorSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=2, vgap=5)

   191

                self.ParamsEditorSizer.AddGrowableCol(0)

   192

                self.ParamsEditorSizer.AddGrowableRow(1)

   193

   194

                self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   195

   196

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   197

                self.ParamsEditorSizer.AddSizer(baseparamseditor_sizer, border=5, 

   198

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

   199

   200

                self.FullIECChannel = wx.StaticText(self.ParamsEditor, -1)

   201

                self.FullIECChannel.SetFont(

   202

                    wx.Font(faces["size"], wx.DEFAULT, wx.NORMAL, 

   203

                            wx.BOLD, faceName = faces["helv"]))

   204

                baseparamseditor_sizer.AddWindow(self.FullIECChannel, 

   205

                      flag=wx.ALIGN_CENTER_VERTICAL)

   206

   207

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   208

                baseparamseditor_sizer.AddSizer(updownsizer, border=5, 

   209

                      flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL)

   210

   211

                self.IECCUpButton = wx.lib.buttons.GenBitmapTextButton(self.ParamsEditor, 

   212

                      bitmap=GetBitmap('IECCDown'), size=wx.Size(16, 16), style=wx.NO_BORDER)

   213

                self.IECCUpButton.Bind(wx.EVT_BUTTON, self.GetItemChannelChangedFunction(1), 

   214

                      self.IECCUpButton)

   215

                updownsizer.AddWindow(self.IECCUpButton, flag=wx.ALIGN_LEFT)

   216

   217

                self.IECCDownButton = wx.lib.buttons.GenBitmapButton(self.ParamsEditor, 

   218

                      bitmap=GetBitmap('IECCUp'), size=wx.Size(16, 16), style=wx.NO_BORDER)

   219

                self.IECCDownButton.Bind(wx.EVT_BUTTON, self.GetItemChannelChangedFunction(-1), 

   220

                      self.IECCDownButton)

   221

                updownsizer.AddWindow(self.IECCDownButton, flag=wx.ALIGN_LEFT)

   222

   223

                self.ConfNodeName = wx.TextCtrl(self.ParamsEditor, 

   224

                      size=wx.Size(150, 25), style=wx.NO_BORDER)

   225

                self.ConfNodeName.SetFont(

   226

                    wx.Font(faces["size"] * 0.75, wx.DEFAULT, wx.NORMAL, 

   227

                            wx.BOLD, faceName = faces["helv"]))

   228

                self.ConfNodeName.Bind(wx.EVT_TEXT, 

   229

                      self.GetTextCtrlCallBackFunction(self.ConfNodeName, "BaseParams.Name", True), 

   230

                      self.ConfNodeName)

   231

                baseparamseditor_sizer.AddWindow(self.ConfNodeName, border=5, 

   232

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

   233

   234

                buttons_sizer = self.GenerateMethodButtonSizer()

   235

                baseparamseditor_sizer.AddSizer(buttons_sizer, flag=wx.ALIGN_CENTER)

   236

   237

            else:

   238

                self.ParamsEditorSizer = wx.FlexGridSizer(cols=1, hgap=0, rows=1, vgap=5)

   239

                self.ParamsEditorSizer.AddGrowableCol(0)

   240

                self.ParamsEditorSizer.AddGrowableRow(0)

   241

   242

            self.ConfNodeParamsSizer = wx.BoxSizer(wx.VERTICAL)

   243

            self.ParamsEditorSizer.AddSizer(self.ConfNodeParamsSizer, border=5, 

   244

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

   245

   246

            self.RefreshConfNodeParamsSizer()

   247

   248

            if self.ConfNodeNoteBook is not None:

   249

                self.ConfNodeNoteBook.AddPage(self.ParamsEditor, _("Config"))

   250

            else:

   251

                self.Editor = self.ParamsEditor

   252

        else:

   253

            self.ParamsEditor = None

   254

   255

    def __init__(self, parent, controler, window, tagname=""):

   256

        EditorPanel.__init__(self, parent, tagname, window, controler)

   257

   258

        icon_name = self.Controler.GetIconName()

   259

        if icon_name is not None:

   260

            self.SetIcon(GetBitmap(icon_name))

   261

        else:

   262

            self.SetIcon(GetBitmap("Extension"))

   263

   264

    def __del__(self):

   265

        self.Controler.OnCloseEditor(self)

   266

   267

    def GetTagName(self):

   268

        return self.Controler.CTNFullName()

   269

   270

    def GetTitle(self):

   271

        fullname = self.Controler.CTNFullName()

   272

        if self.Controler.CTNTestModified():

   273

            return "~%s~" % fullname

   274

        return fullname

   275

   276

    def HasNoModel(self):

   277

        return False

   278

   279

    def GetBufferState(self):

   280

        return False, False

   281

   282

    def Undo(self):

   283

        pass

   284

   285

    def Redo(self):

   286

        pass

   287

   288

    def RefreshView(self):

   289

        EditorPanel.RefreshView(self)

   290

        if self.ParamsEditor is not None:

   291

            if self.SHOW_BASE_PARAMS:

   292

                self.ConfNodeName.ChangeValue(self.Controler.MandatoryParams[1].getName())

   293

                self.RefreshIECChannelControlsState()

   294

            self.RefreshConfNodeParamsSizer()

   295

            self.RefreshScrollbars()

   296

   297

    def EnableScrolling(self, enable):

   298

        self.ScrollingEnabled = enable

   299

   300

    def RefreshIECChannelControlsState(self):

   301

        self.FullIECChannel.SetLabel(self.Controler.GetFullIEC_Channel())

   302

        self.IECCDownButton.Enable(self.Controler.BaseParams.getIEC_Channel() > 0)

   303

   304

    def RefreshConfNodeParamsSizer(self):

   305

        self.Freeze()

   306

        self.ConfNodeParamsSizer.Clear(True)

   307

   308

        confnode_infos = self.Controler.GetParamsAttributes()

   309

        if len(confnode_infos) > 0:

   310

            self.GenerateSizerElements(self.ConfNodeParamsSizer, confnode_infos, None, False)

   311

   312

        self.ParamsEditorSizer.Layout()

   313

        self.Thaw()

   314

   315

    def GenerateMethodButtonSizer(self):

   316

        normal_bt_font=wx.Font(faces["size"] / 3, wx.DEFAULT, wx.NORMAL, wx.NORMAL, faceName = faces["helv"])

   317

        mouseover_bt_font=wx.Font(faces["size"] / 3, wx.DEFAULT, wx.NORMAL, wx.NORMAL, underline=True, faceName = faces["helv"])

   318

   319

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   320

   321

        for confnode_method in self.Controler.ConfNodeMethods:

   322

            if "method" in confnode_method and confnode_method.get("shown",True):

   323

                button = GenBitmapTextButton(self.ParamsEditor,

   324

                    bitmap=GetBitmap(confnode_method.get("bitmap", "Unknown")), 

   325

                    label=confnode_method["name"], style=wx.NO_BORDER)

   326

                button.SetFont(normal_bt_font)

   327

                button.SetToolTipString(confnode_method["tooltip"])

   328

                if confnode_method.get("push", False):

   329

                    button.Bind(wx.EVT_LEFT_DOWN, self.GetButtonCallBackFunction(confnode_method["method"], True))

   330

                else:

   331

                    button.Bind(wx.EVT_BUTTON, self.GetButtonCallBackFunction(confnode_method["method"]), button)

   332

                # a fancy underline on mouseover

   333

                def setFontStyle(b, s):

   334

                    def fn(event):

   335

                        b.SetFont(s)

   336

                        b.Refresh()

   337

                        event.Skip()

   338

                    return fn

   339

                button.Bind(wx.EVT_ENTER_WINDOW, setFontStyle(button, mouseover_bt_font))

   340

                button.Bind(wx.EVT_LEAVE_WINDOW, setFontStyle(button, normal_bt_font))

   341

                #hack to force size to mini

   342

                if not confnode_method.get("enabled",True):

   343

                    button.Disable()

   344

                msizer.AddWindow(button, flag=wx.ALIGN_CENTER)

   345

        return msizer

   346

   347

    def GenerateSizerElements(self, sizer, elements, path, clean = True):

   348

        if clean:

   349

            sizer.Clear(True)

   350

        first = True

   351

        for element_infos in elements:

   352

            if path:

   353

                element_path = "%s.%s"%(path, element_infos["name"])

   354

            else:

   355

                element_path = element_infos["name"]

   356

            if element_infos["type"] == "element":

   357

                label = element_infos["name"]

   358

                staticbox = wx.StaticBox(self.ParamsEditor, 

   359

                      label=_(label), size=wx.Size(10, 0))

   360

                staticboxsizer = wx.StaticBoxSizer(staticbox, wx.VERTICAL)

   361

                if first:

   362

                    sizer.AddSizer(staticboxsizer, border=5, 

   363

                          flag=wx.GROW|wx.TOP|wx.BOTTOM)

   364

                else:

   365

                    sizer.AddSizer(staticboxsizer, border=5, 

   366

                          flag=wx.GROW|wx.BOTTOM)

   367

                self.GenerateSizerElements(staticboxsizer, 

   368

                                           element_infos["children"], 

   369

                                           element_path)

   370

            else:

   371

                boxsizer = wx.FlexGridSizer(cols=3, rows=1)

   372

                boxsizer.AddGrowableCol(1)

   373

                if first:

   374

                    sizer.AddSizer(boxsizer, border=5, 

   375

                          flag=wx.GROW|wx.ALL)

   376

                else:

   377

                    sizer.AddSizer(boxsizer, border=5, 

   378

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

   379

   380

                staticbitmap = GenStaticBitmap(ID=-1, bitmapname=element_infos["name"],

   381

                    name="%s_bitmap"%element_infos["name"], parent=self.ParamsEditor,

   382

                    pos=wx.Point(0, 0), size=wx.Size(24, 24), style=0)

   383

                boxsizer.AddWindow(staticbitmap, border=5, flag=wx.RIGHT)

   384

   385

                statictext = wx.StaticText(self.ParamsEditor, 

   386

                      label="%s:"%_(element_infos["name"]))

   387

                boxsizer.AddWindow(statictext, border=5, 

   388

                      flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT)

   389

   390

                if isinstance(element_infos["type"], types.ListType):

   391

                    if isinstance(element_infos["value"], types.TupleType):

   392

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   393

                        boxsizer.AddSizer(browse_boxsizer)

   394

   395

                        textctrl = wx.TextCtrl(self.ParamsEditor, 

   396

                              size=wx.Size(275, -1), style=wx.TE_READONLY)

   397

                        if element_infos["value"] is not None:

   398

                            textctrl.SetValue(element_infos["value"][0])

   399

                            value_infos = element_infos["value"][1]

   400

                        else:

   401

                            value_infos = None

   402

                        browse_boxsizer.AddWindow(textctrl)

   403

   404

                        button = wx.Button(self.ParamsEditor, 

   405

                              label="...", size=wx.Size(25, 25))

   406

                        browse_boxsizer.AddWindow(button)

   407

                        button.Bind(wx.EVT_BUTTON, 

   408

                                    self.GetBrowseCallBackFunction(element_infos["name"], textctrl, element_infos["type"], 

   409

                                                                   value_infos, element_path), 

   410

                                    button)

   411

                    else:

   412

                        combobox = wx.ComboBox(self.ParamsEditor, 

   413

                              size=wx.Size(300, -1), style=wx.CB_READONLY)

   414

                        boxsizer.AddWindow(combobox)

   415

   416

                        if element_infos["use"] == "optional":

   417

                            combobox.Append("")

   418

                        if len(element_infos["type"]) > 0 and isinstance(element_infos["type"][0], types.TupleType):

   419

                            for choice, xsdclass in element_infos["type"]:

   420

                                combobox.Append(choice)

   421

                            name = element_infos["name"]

   422

                            value = element_infos["value"]

   423

   424

                            staticbox = wx.StaticBox(self.ParamsEditor, 

   425

                                  label="%s - %s"%(_(name), _(value)), size=wx.Size(10, 0))

   426

                            staticboxsizer = wx.StaticBoxSizer(staticbox, wx.VERTICAL)

   427

                            sizer.AddSizer(staticboxsizer, border=5, flag=wx.GROW|wx.BOTTOM)

   428

                            self.GenerateSizerElements(staticboxsizer, element_infos["children"], element_path)

   429

                            callback = self.GetChoiceContentCallBackFunction(combobox, staticboxsizer, element_path)

   430

                        else:

   431

                            for choice in element_infos["type"]:

   432

                                combobox.Append(choice)

   433

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   434

                        if element_infos["value"] is None:

   435

                            combobox.SetStringSelection("")

   436

                        else:

   437

                            combobox.SetStringSelection(element_infos["value"])

   438

                        combobox.Bind(wx.EVT_COMBOBOX, callback, combobox)

   439

   440

                elif isinstance(element_infos["type"], types.DictType):

   441

                    scmin = -(2**31)

   442

                    scmax = 2**31-1

   443

                    if "min" in element_infos["type"]:

   444

                        scmin = element_infos["type"]["min"]

   445

                    if "max" in element_infos["type"]:

   446

                        scmax = element_infos["type"]["max"]

   447

                    spinctrl = wx.SpinCtrl(self.ParamsEditor, 

   448

                          size=wx.Size(300, -1), style=wx.SP_ARROW_KEYS|wx.ALIGN_RIGHT)

   449

                    spinctrl.SetRange(scmin, scmax)

   450

                    boxsizer.AddWindow(spinctrl)

   451

                    if element_infos["value"] is not None:

   452

                        spinctrl.SetValue(element_infos["value"])

   453

                    spinctrl.Bind(wx.EVT_SPINCTRL, 

   454

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   455

                                  spinctrl)

   456

   457

                else:

   458

                    if element_infos["type"] == "boolean":

   459

                        checkbox = wx.CheckBox(self.ParamsEditor, size=wx.Size(17, 25))

   460

                        boxsizer.AddWindow(checkbox)

   461

                        if element_infos["value"] is not None:

   462

                            checkbox.SetValue(element_infos["value"])

   463

                        checkbox.Bind(wx.EVT_CHECKBOX, 

   464

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path), 

   465

                                      checkbox)

   466

   467

                    elif element_infos["type"] in ["unsignedLong", "long","integer"]:

   468

                        if element_infos["type"].startswith("unsigned"):

   469

                            scmin = 0

   470

                        else:

   471

                            scmin = -(2**31)

   472

                        scmax = 2**31-1

   473

                        spinctrl = wx.SpinCtrl(self.ParamsEditor, 

   474

                              size=wx.Size(300, -1), style=wx.SP_ARROW_KEYS|wx.ALIGN_RIGHT)

   475

                        spinctrl.SetRange(scmin, scmax)

   476

                        boxsizer.AddWindow(spinctrl)

   477

                        if element_infos["value"] is not None:

   478

                            spinctrl.SetValue(element_infos["value"])

   479

                        spinctrl.Bind(wx.EVT_SPINCTRL, 

   480

                                      self.GetTextCtrlCallBackFunction(spinctrl, element_path), 

   481

                                      spinctrl)

   482

   483

                    else:

   484

                        choices = self.ParentWindow.GetConfigEntry(element_path, [""])

   485

                        textctrl = TextCtrlAutoComplete(name=element_infos["name"], 

   486

                                                        parent=self.ParamsEditor, 

   487

                                                        appframe=self, 

   488

                                                        choices=choices, 

   489

                                                        element_path=element_path,

   490

                                                        size=wx.Size(300, -1))

   491

   492

                        boxsizer.AddWindow(textctrl)

   493

                        if element_infos["value"] is not None:

   494

                            textctrl.ChangeValue(str(element_infos["value"]))

   495

                        textctrl.Bind(wx.EVT_TEXT, self.GetTextCtrlCallBackFunction(textctrl, element_path))

   496

            first = False

   497

   498

   499

    def GetItemChannelChangedFunction(self, dir):

   500

        def OnConfNodeTreeItemChannelChanged(event):

   501

            confnode_IECChannel = self.Controler.BaseParams.getIEC_Channel()

   502

            res = self.SetConfNodeParamsAttribute("BaseParams.IEC_Channel", confnode_IECChannel + dir)

   503

            wx.CallAfter(self.RefreshIECChannelControlsState)

   504

            wx.CallAfter(self.ParentWindow._Refresh, TITLE, FILEMENU, PROJECTTREE)

   505

            wx.CallAfter(self.ParentWindow.SelectProjectTreeItem, self.GetTagName())

   506

            event.Skip()

   507

        return OnConfNodeTreeItemChannelChanged