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

import os

    27

import types

    28

    29

import wx

    30

    31

from EditorPanel import EditorPanel

    32

    33

from IDEFrame import TITLE, FILEMENU, PROJECTTREE, PAGETITLES

    34

    35

from controls import TextCtrlAutoComplete

    36

from dialogs import BrowseValuesLibraryDialog

    37

from util.BitmapLibrary import GetBitmap

    38

    39

if wx.Platform == '__WXMSW__':

    40

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

    41

              'mono' : 'Courier New',

    42

              'helv' : 'Arial',

    43

              'other': 'Comic Sans MS',

    44

              'size' : 16,

    45

             }

    46

else:

    47

    faces = { 'times': 'Times',

    48

              'mono' : 'Courier',

    49

              'helv' : 'Helvetica',

    50

              'other': 'new century schoolbook',

    51

              'size' : 18,

    52

             }

    53

    54

SCROLLBAR_UNIT = 10

    55

    56

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

    57

    def _GetLabelSize(self):

    58

        """ used internally """

    59

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

    60

        if not self.bmpLabel:

    61

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

    62

    63

        w_bmp = self.bmpLabel.GetWidth()+2

    64

        h_bmp = self.bmpLabel.GetHeight()+2

    65

        height = h + h_bmp

    66

        if w_bmp > w:

    67

            width = w_bmp

    68

        else:

    69

            width = w

    70

        return width, height, False

    71

    72

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

    73

        bmp = self.bmpLabel

    74

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

    75

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

    76

                bmp = self.bmpDisabled

    77

            if self.bmpFocus and self.hasFocus:

    78

                bmp = self.bmpFocus

    79

            if self.bmpSelected and not self.up:

    80

                bmp = self.bmpSelected

    81

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

    82

            if not self.up:

    83

                dw = dy = self.labelDelta

    84

            hasMask = bmp.GetMask() != None

    85

        else:

    86

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

    87

    88

        dc.SetFont(self.GetFont())

    89

        if self.IsEnabled():

    90

            dc.SetTextForeground(self.GetForegroundColour())

    91

        else:

    92

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

    93

    94

        label = self.GetLabel()

    95

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

    96

        if not self.up:

    97

            dw = dy = self.labelDelta

    98

    99

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

   100

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

   101

        if bmp !=None:

   102

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

   103

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

   104

            pos_y += bh + 2

   105

   106

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

   107

   108

   109

class GenStaticBitmap(wx.StaticBitmap):

   110

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

   111

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

   112

    def __init__(self, parent, ID, bitmapname,

   113

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

   114

                 style = 0,

   115

                 name = "genstatbmp"):

   116

   117

        bitmap = GetBitmap(bitmapname)

   118

        if bitmap is None:

   119

            bitmap = wx.EmptyBitmap(0, 0)

   120

   121

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

   122

                 bitmap,

   123

                 pos, size,

   124

                 style,

   125

                 name)

   126

   127

class ConfTreeNodeEditor(EditorPanel):

   128

   129

    SHOW_BASE_PARAMS = True

   130

    SHOW_PARAMS = True

   131

    CONFNODEEDITOR_TABS = []

   132

   133

    def _init_Editor(self, parent):

   134

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   135

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

   136

            tabs_num += 1

   137

   138

        if tabs_num > 1 or self.SHOW_BASE_PARAMS:

   139

            self.Editor = wx.Panel(parent,

   140

                style=wx.SUNKEN_BORDER|wx.SP_3D)

   141

   142

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

   143

   144

            if self.SHOW_BASE_PARAMS:

   145

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   146

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

   147

                      flag=wx.GROW|wx.ALL)

   148

   149

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

   150

                self.FullIECChannel.SetFont(

   151

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

   152

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

   153

                baseparamseditor_sizer.AddWindow(self.FullIECChannel,

   154

                      flag=wx.ALIGN_CENTER_VERTICAL)

   155

   156

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   157

                baseparamseditor_sizer.AddSizer(updownsizer, border=5,

   158

                      flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL)

   159

   160

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

   161

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

   162

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

   163

                      self.IECCUpButton)

   164

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

   165

   166

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

   167

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

   168

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

   169

                      self.IECCDownButton)

   170

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

   171

   172

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

   173

                      size=wx.Size(150, 25))

   174

                self.ConfNodeName.SetFont(

   175

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

   176

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

   177

                self.ConfNodeName.Bind(wx.EVT_TEXT,

   178

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

   179

                      self.ConfNodeName)

   180

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

   181

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

   182

   183

                buttons_sizer = self.GenerateMethodButtonSizer()

   184

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

   185

   186

            if tabs_num > 1:

   187

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

   188

                parent = self.ConfNodeNoteBook

   189

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

   190

            else:

   191

                parent = self.Editor

   192

                self.ConfNodeNoteBook = None

   193

   194

            self.Editor.SetSizer(self.MainSizer)

   195

        else:

   196

            self.ConfNodeNoteBook = None

   197

            self.Editor = None

   198

   199

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   200

            editor = getattr(self, create_func_name)(parent)

   201

            if self.ConfNodeNoteBook is not None:

   202

                self.ConfNodeNoteBook.AddPage(editor, title)

   203

            elif self.SHOW_BASE_PARAMS:

   204

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

   205

            else:

   206

                self.Editor = editor

   207

   208

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

   209

   210

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

   211

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

   212

                panel_style |= wx.SUNKEN_BORDER

   213

            self.ParamsEditor = wx.ScrolledWindow(parent,

   214

                  style=panel_style)

   215

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

   216

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

   217

   218

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

   219

            self.ParamsEditorSizer.AddGrowableCol(0)

   220

            self.ParamsEditorSizer.AddGrowableRow(0)

   221

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   222

   223

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

   224

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

   225

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

   226

   227

            self.RefreshConfNodeParamsSizer()

   228

   229

            if self.ConfNodeNoteBook is not None:

   230

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

   231

            elif self.SHOW_BASE_PARAMS:

   232

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

   233

            else:

   234

                self.Editor = self.ParamsEditor

   235

        else:

   236

            self.ParamsEditor = None

   237

   238

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

   239

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

   240

   241

        icon_name = self.Controler.GetIconName()

   242

        if icon_name is not None:

   243

            self.SetIcon(GetBitmap(icon_name))

   244

        else:

   245

            self.SetIcon(GetBitmap("Extension"))

   246

   247

    def __del__(self):

   248

        self.Controler.OnCloseEditor(self)

   249

   250

    def GetTagName(self):

   251

        return self.Controler.CTNFullName()

   252

   253

    def GetTitle(self):

   254

        fullname = self.Controler.CTNFullName()

   255

        if self.Controler.CTNTestModified():

   256

            return "~%s~" % fullname

   257

        return fullname

   258

   259

    def HasNoModel(self):

   260

        return False

   261

   262

    def GetBufferState(self):

   263

        return False, False

   264

   265

    def Undo(self):

   266

        pass

   267

   268

    def Redo(self):

   269

        pass

   270

   271

    def RefreshView(self):

   272

        EditorPanel.RefreshView(self)

   273

        if self.SHOW_BASE_PARAMS:

   274

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

   275

            self.RefreshIECChannelControlsState()

   276

        if self.ParamsEditor is not None:

   277

            self.RefreshConfNodeParamsSizer()

   278

            self.RefreshScrollbars()

   279

   280

    def RefreshIECChannelControlsState(self):

   281

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

   282

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

   283

        self.MainSizer.Layout()

   284

   285

    def RefreshConfNodeParamsSizer(self):

   286

        self.Freeze()

   287

        self.ConfNodeParamsSizer.Clear(True)

   288

   289

        confnode_infos = self.Controler.GetParamsAttributes()

   290

        if len(confnode_infos) > 0:

   291

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

   292

   293

        self.ParamsEditorSizer.Layout()

   294

        self.Thaw()

   295

   296

    def GenerateMethodButtonSizer(self):

   297

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

   298

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

   299

   300

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   301

   302

        for confnode_method in self.Controler.ConfNodeMethods:

   303

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

   304

                button = GenBitmapTextButton(self.Editor,

   305

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

   306

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

   307

                button.SetFont(normal_bt_font)

   308

                button.SetToolTipString(confnode_method["tooltip"])

   309

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

   310

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

   311

                else:

   312

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

   313

                # a fancy underline on mouseover

   314

                def setFontStyle(b, s):

   315

                    def fn(event):

   316

                        b.SetFont(s)

   317

                        b.Refresh()

   318

                        event.Skip()

   319

                    return fn

   320

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

   321

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

   322

                #hack to force size to mini

   323

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

   324

                    button.Disable()

   325

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

   326

        return msizer

   327

   328

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

   329

        if clean:

   330

            sizer.Clear(True)

   331

        first = True

   332

        for element_infos in elements:

   333

            if path:

   334

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

   335

            else:

   336

                element_path = element_infos["name"]

   337

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

   338

                name = element_infos["name"]

   339

                value = element_infos["value"]

   340

                label = _(name)

   341

                if value is not None:

   342

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

   343

                staticbox = wx.StaticBox(self.ParamsEditor,

   344

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

   345

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

   346

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

   347

                if first:

   348

                    flags |= wx.TOP

   349

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

   350

                self.GenerateSizerElements(staticboxsizer,

   351

                                           element_infos["children"],

   352

                                           element_path)

   353

            else:

   354

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

   355

                boxsizer.AddGrowableCol(1)

   356

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

   357

                if first:

   358

                    flags |= wx.TOP

   359

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

   360

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

   361

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

   362

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

   363

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

   364

   365

                statictext = wx.StaticText(self.ParamsEditor,

   366

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

   367

                boxsizer.AddWindow(statictext, border=5,

   368

                      flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT)

   369

   370

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

   371

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

   372

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   373

                        boxsizer.AddSizer(browse_boxsizer)

   374

   375

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   376

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

   377

                        if element_infos["value"] is not None:

   378

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

   379

                            value_infos = element_infos["value"][1]

   380

                        else:

   381

                            value_infos = None

   382

                        browse_boxsizer.AddWindow(textctrl)

   383

   384

                        button = wx.Button(self.ParamsEditor, label="...")

   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