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

#

     9

# See COPYING file for copyrights details.

    10

#

    11

# This program is free software; you can redistribute it and/or

    12

# modify it under the terms of the GNU General Public License

    13

# as published by the Free Software Foundation; either version 2

    14

# of the License, or (at your option) any later version.

    15

#

    16

# This program is distributed in the hope that it will be useful,

    17

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    18

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    19

# GNU General Public License for more details.

    20

#

    21

# You should have received a copy of the GNU General Public License

    22

# along with this program; if not, write to the Free Software

    23

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

    24

    25

import os

    26

import types

    27

    28

import wx

    29

    30

from EditorPanel import EditorPanel

    31

    32

from IDEFrame import TITLE, FILEMENU, PROJECTTREE, PAGETITLES

    33

    34

from controls import TextCtrlAutoComplete

    35

from dialogs import BrowseValuesLibraryDialog

    36

from util.BitmapLibrary import GetBitmap

    37

    38

if wx.Platform == '__WXMSW__':

    39

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

    40

              'mono' : 'Courier New',

    41

              'helv' : 'Arial',

    42

              'other': 'Comic Sans MS',

    43

              'size' : 16,

    44

             }

    45

else:

    46

    faces = { 'times': 'Times',

    47

              'mono' : 'Courier',

    48

              'helv' : 'Helvetica',

    49

              'other': 'new century schoolbook',

    50

              'size' : 18,

    51

             }

    52

    53

SCROLLBAR_UNIT = 10

    54

    55

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

    56

    def _GetLabelSize(self):

    57

        """ used internally """

    58

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

    59

        if not self.bmpLabel:

    60

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

    61

    62

        w_bmp = self.bmpLabel.GetWidth()+2

    63

        h_bmp = self.bmpLabel.GetHeight()+2

    64

        height = h + h_bmp

    65

        if w_bmp > w:

    66

            width = w_bmp

    67

        else:

    68

            width = w

    69

        return width, height, False

    70

    71

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

    72

        bmp = self.bmpLabel

    73

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

    74

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

    75

                bmp = self.bmpDisabled

    76

            if self.bmpFocus and self.hasFocus:

    77

                bmp = self.bmpFocus

    78

            if self.bmpSelected and not self.up:

    79

                bmp = self.bmpSelected

    80

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

    81

            if not self.up:

    82

                dw = dy = self.labelDelta

    83

            hasMask = bmp.GetMask() != None

    84

        else:

    85

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

    86

    87

        dc.SetFont(self.GetFont())

    88

        if self.IsEnabled():

    89

            dc.SetTextForeground(self.GetForegroundColour())

    90

        else:

    91

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

    92

    93

        label = self.GetLabel()

    94

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

    95

        if not self.up:

    96

            dw = dy = self.labelDelta

    97

    98

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

    99

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

   100

        if bmp !=None:

   101

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

   102

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

   103

            pos_y += bh + 2

   104

   105

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

   106

   107

   108

class GenStaticBitmap(wx.StaticBitmap):

   109

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

   110

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

   111

    def __init__(self, parent, ID, bitmapname,

   112

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

   113

                 style = 0,

   114

                 name = "genstatbmp"):

   115

   116

        bitmap = GetBitmap(bitmapname)

   117

        if bitmap is None:

   118

            bitmap = wx.EmptyBitmap(0, 0)

   119

   120

        wx.StaticBitmap.__init__(self, parent, ID,

   121

                 bitmap,

   122

                 pos, size,

   123

                 style,

   124

                 name)

   125

   126

class ConfTreeNodeEditor(EditorPanel):

   127

   128

    SHOW_BASE_PARAMS = True

   129

    SHOW_PARAMS = True

   130

    CONFNODEEDITOR_TABS = []

   131

   132

    def _init_Editor(self, parent):

   133

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   134

        if self.SHOW_PARAMS and len(self.Controler.GetParamsAttributes()) > 0:

   135

            tabs_num += 1

   136

   137

        if tabs_num > 1 or self.SHOW_BASE_PARAMS:

   138

            self.Editor = wx.Panel(parent,

   139

                style=wx.SUNKEN_BORDER|wx.SP_3D)

   140

   141

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

   142

   143

            if self.SHOW_BASE_PARAMS:

   144

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   145

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

   146

                      flag=wx.GROW|wx.ALL)

   147

   148

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

   149

                self.FullIECChannel.SetFont(

   150

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

   151

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

   152

                baseparamseditor_sizer.AddWindow(self.FullIECChannel,

   153

                      flag=wx.ALIGN_CENTER_VERTICAL)

   154

   155

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   156

                baseparamseditor_sizer.AddSizer(updownsizer, border=5,

   157

                      flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL)

   158

   159

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

   160

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

   161

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

   162

                      self.IECCUpButton)

   163

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

   164

   165

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

   166

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

   167

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

   168

                      self.IECCDownButton)

   169

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

   170

   171

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

   172

                      size=wx.Size(150, 25))

   173

                self.ConfNodeName.SetFont(

   174

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

   175

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

   176

                self.ConfNodeName.Bind(wx.EVT_TEXT,

   177

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

   178

                      self.ConfNodeName)

   179

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

   180

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

   181

   182

                buttons_sizer = self.GenerateMethodButtonSizer()

   183

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

   184

   185

            if tabs_num > 1:

   186

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

   187

                parent = self.ConfNodeNoteBook

   188

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

   189

            else:

   190

                parent = self.Editor

   191

                self.ConfNodeNoteBook = None

   192

   193

            self.Editor.SetSizer(self.MainSizer)

   194

        else:

   195

            self.ConfNodeNoteBook = None

   196

            self.Editor = None

   197

   198

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   199

            editor = getattr(self, create_func_name)(parent)

   200

            if self.ConfNodeNoteBook is not None:

   201

                self.ConfNodeNoteBook.AddPage(editor, title)

   202

            elif self.SHOW_BASE_PARAMS:

   203

                self.MainSizer.AddWindow(editor, 1, flag=wx.GROW)

   204

            else:

   205

                self.Editor = editor

   206

   207

        if self.SHOW_PARAMS and len(self.Controler.GetParamsAttributes()) > 0:

   208

   209

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

   210

            if self.ConfNodeNoteBook is None and parent != self.Editor:

   211

                panel_style |= wx.SUNKEN_BORDER

   212

            self.ParamsEditor = wx.ScrolledWindow(parent,

   213

                  style=panel_style)

   214

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

   215

            self.ParamsEditor.Bind(wx.EVT_SCROLLWIN, self.OnParamsEditorScroll)

   216

   217

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

   218

            self.ParamsEditorSizer.AddGrowableCol(0)

   219

            self.ParamsEditorSizer.AddGrowableRow(0)

   220

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   221

   222

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

   223

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

   224

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

   225

   226

            self.RefreshConfNodeParamsSizer()

   227

   228

            if self.ConfNodeNoteBook is not None:

   229

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

   230

            elif self.SHOW_BASE_PARAMS:

   231

                self.MainSizer.AddWindow(self.ParamsEditor, 1, flag=wx.GROW)

   232

            else:

   233

                self.Editor = self.ParamsEditor

   234

        else:

   235

            self.ParamsEditor = None

   236

   237

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

   238

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

   239

   240

        icon_name = self.Controler.GetIconName()

   241

        if icon_name is not None:

   242

            self.SetIcon(GetBitmap(icon_name))

   243

        else:

   244

            self.SetIcon(GetBitmap("Extension"))

   245

   246

    def __del__(self):

   247

        self.Controler.OnCloseEditor(self)

   248

   249

    def GetTagName(self):

   250

        return self.Controler.CTNFullName()

   251

   252

    def GetTitle(self):

   253

        fullname = self.Controler.CTNFullName()

   254

        if self.Controler.CTNTestModified():

   255

            return "~%s~" % fullname

   256

        return fullname

   257

   258

    def HasNoModel(self):

   259

        return False

   260

   261

    def GetBufferState(self):

   262

        return False, False

   263

   264

    def Undo(self):

   265

        pass

   266

   267

    def Redo(self):

   268

        pass

   269

   270

    def RefreshView(self):

   271

        EditorPanel.RefreshView(self)

   272

        if self.SHOW_BASE_PARAMS:

   273

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

   274

            self.RefreshIECChannelControlsState()

   275

        if self.ParamsEditor is not None:

   276

            self.RefreshConfNodeParamsSizer()

   277

            self.RefreshScrollbars()

   278

   279

    def RefreshIECChannelControlsState(self):

   280

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

   281

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

   282

        self.MainSizer.Layout()

   283

   284

    def RefreshConfNodeParamsSizer(self):

   285

        self.Freeze()

   286

        self.ConfNodeParamsSizer.Clear(True)

   287

   288

        confnode_infos = self.Controler.GetParamsAttributes()

   289

        if len(confnode_infos) > 0:

   290

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

   291

   292

        self.ParamsEditorSizer.Layout()

   293

        self.Thaw()

   294

   295

    def GenerateMethodButtonSizer(self):

   296

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

   297

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

   298

   299

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   300

   301

        for confnode_method in self.Controler.ConfNodeMethods:

   302

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

   303

                button = GenBitmapTextButton(self.Editor,

   304

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

   305

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

   306

                button.SetFont(normal_bt_font)

   307

                button.SetToolTipString(confnode_method["tooltip"])

   308

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

   309

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

   310

                else:

   311

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

   312

                # a fancy underline on mouseover

   313

                def setFontStyle(b, s):

   314

                    def fn(event):

   315

                        b.SetFont(s)

   316

                        b.Refresh()

   317

                        event.Skip()

   318

                    return fn

   319

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

   320

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

   321

                #hack to force size to mini

   322

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

   323

                    button.Disable()

   324

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

   325

        return msizer

   326

   327

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

   328

        if clean:

   329

            sizer.Clear(True)

   330

        first = True

   331

        for element_infos in elements:

   332

            if path:

   333

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

   334

            else:

   335

                element_path = element_infos["name"]

   336

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

   337

                name = element_infos["name"]

   338

                value = element_infos["value"]

   339

                label = _(name)

   340

                if value is not None:

   341

                    label += " - %s" % _(value)

   342

                staticbox = wx.StaticBox(self.ParamsEditor,

   343

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

   344

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

   345

                flags = (wx.GROW | wx.BOTTOM | wx.LEFT | wx.RIGHT)

   346

                if first:

   347

                    flags |= wx.TOP

   348

                sizer.AddSizer(staticboxsizer, border=5, flag=flags)

   349

                self.GenerateSizerElements(staticboxsizer,

   350

                                           element_infos["children"],

   351

                                           element_path)

   352

            else:

   353

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

   354

                boxsizer.AddGrowableCol(1)

   355

                flags = (wx.GROW | wx.BOTTOM | wx.LEFT | wx.RIGHT)

   356

                if first:

   357

                    flags |= wx.TOP

   358

                sizer.AddSizer(boxsizer, border=5, flag=flags)

   359

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

   360

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

   361

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

   362

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

   363

   364

                statictext = wx.StaticText(self.ParamsEditor,

   365

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

   366

                boxsizer.AddWindow(statictext, border=5,

   367

                      flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT)

   368

   369

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

   370

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

   371

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   372

                        boxsizer.AddSizer(browse_boxsizer)

   373

   374

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   375

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

   376

                        if element_infos["value"] is not None:

   377

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

   378

                            value_infos = element_infos["value"][1]

   379

                        else:

   380

                            value_infos = None

   381

                        browse_boxsizer.AddWindow(textctrl)

   382

   383

                        button = wx.Button(self.ParamsEditor,

   384

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

   385

                        browse_boxsizer.AddWindow(button)

   386

                        button.Bind(wx.EVT_BUTTON,

   387

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

   388

                                                                   value_infos, element_path),

   389

                                    button)

   390

                    else:

   391

                        combobox = wx.ComboBox(self.ParamsEditor,

   392

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

   393

                        boxsizer.AddWindow(combobox)

   394

   395

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

   396

                            combobox.Append("")

   397

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

   398

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

   399

                                combobox.Append(choice)

   400

                            name = element_infos["name"]

   401

                            value = element_infos["value"]

   402

   403

                            staticbox = wx.StaticBox(self.ParamsEditor,

   404

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

   405

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

   406

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

   407

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

   408

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

   409

                        else:

   410

                            for choice in element_infos["type"]:

   411

                                combobox.Append(choice)

   412

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   413

                        if element_infos["value"] is None:

   414

                            combobox.SetStringSelection("")

   415

                        else:

   416

                            combobox.SetStringSelection(element_infos["value"])

   417

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

   418

   419

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

   420

                    scmin = -(2**31)

   421

                    scmax = 2**31-1

   422

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

   423

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

   424

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

   425

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

   426

                    spinctrl = wx.SpinCtrl(self.ParamsEditor,

   427

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

   428

                    spinctrl.SetRange(scmin, scmax)

   429

                    boxsizer.AddWindow(spinctrl)

   430

                    if element_infos["value"] is not None:

   431

                        spinctrl.SetValue(element_infos["value"])

   432

                    spinctrl.Bind(wx.EVT_SPINCTRL,

   433

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   434

                                  spinctrl)

   435

   436

                else:

   437

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

   438

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

   439

                        boxsizer.AddWindow(checkbox)

   440

                        if element_infos["value"] is not None:

   441

                            checkbox.SetValue(element_infos["value"])

   442

                        checkbox.Bind(wx.EVT_CHECKBOX,

   443

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path),

   444

                                      checkbox)

   445

   446

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

   447

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

   448

                            scmin = 0

   449

                        else:

   450

                            scmin = -(2**31)

   451

                        scmax = 2**31-1

   452

                        spinctrl = wx.SpinCtrl(self.ParamsEditor,

   453

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

   454

                        spinctrl.SetRange(scmin, scmax)

   455

                        boxsizer.AddWindow(spinctrl)

   456

                        if element_infos["value"] is not None:

   457

                            spinctrl.SetValue(element_infos["value"])

   458

                        spinctrl.Bind(wx.EVT_SPINCTRL,

   459

                                      self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   460

                                      spinctrl)

   461

   462

                    else:

   463

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

   464

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

   465

                                                        parent=self.ParamsEditor,

   466

                                                        choices=choices,

   467

                                                        element_path=element_path,

   468

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

   469

   470

                        boxsizer.AddWindow(textctrl)

   471

                        if element_infos["value"] is not None:

   472

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

   473

                        callback = self.GetTextCtrlCallBackFunction(textctrl, element_path)

   474

                        textctrl.Bind(wx.EVT_TEXT_ENTER, callback)

   475

                        textctrl.Bind(wx.EVT_KILL_FOCUS, callback)

   476

            first = False

   477

        sizer.Layout()

   478

        self.RefreshScrollbars()

   479

   480

   481

    def GetItemChannelChangedFunction(self, dir):

   482

        def OnConfNodeTreeItemChannelChanged(event):

   483

            confnode_IECChannel = self.Controler.BaseParams.getIEC_Channel()

   484

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

   485

            wx.CallAfter(self.RefreshIECChannelControlsState)

   486

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

   487

            event.Skip()

   488

        return OnConfNodeTreeItemChannelChanged

   489

   490

    def SetConfNodeParamsAttribute(self, *args, **kwargs):

   491

        res, StructChanged = self.Controler.SetParamsAttribute(*args, **kwargs)

   492

        if StructChanged and self.ParamsEditor is not None:

   493

            wx.CallAfter(self.RefreshConfNodeParamsSizer)

   494

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

   495

        return res

   496