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

                if first:

   346

                    sizer.AddSizer(staticboxsizer, border=5,

   347

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

   348

                else:

   349

                    sizer.AddSizer(staticboxsizer, border=5,

   350

                          flag=wx.GROW|wx.BOTTOM)

   351

                self.GenerateSizerElements(staticboxsizer,

   352

                                           element_infos["children"],

   353

                                           element_path)

   354

            else:

   355

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

   356

                boxsizer.AddGrowableCol(1)

   357

                if first:

   358

                    sizer.AddSizer(boxsizer, border=5,

   359

                          flag=wx.GROW|wx.ALL)

   360

                else:

   361

                    sizer.AddSizer(boxsizer, border=5,

   362

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

   363

   364

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

   365

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

   366

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

   367

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

   368

   369

                statictext = wx.StaticText(self.ParamsEditor,

   370

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

   371

                boxsizer.AddWindow(statictext, border=5,

   372

                      flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT)

   373

   374

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

   375

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

   376

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   377

                        boxsizer.AddSizer(browse_boxsizer)

   378

   379

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   380

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

   381

                        if element_infos["value"] is not None:

   382

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

   383

                            value_infos = element_infos["value"][1]

   384

                        else:

   385

                            value_infos = None

   386

                        browse_boxsizer.AddWindow(textctrl)

   387

   388

                        button = wx.Button(self.ParamsEditor,

   389

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

   390

                        browse_boxsizer.AddWindow(button)

   391

                        button.Bind(wx.EVT_BUTTON,

   392

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

   393

                                                                   value_infos, element_path),

   394

                                    button)

   395

                    else:

   396

                        combobox = wx.ComboBox(self.ParamsEditor,

   397

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

   398

                        boxsizer.AddWindow(combobox)

   399

   400

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

   401

                            combobox.Append("")

   402

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

   403

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

   404

                                combobox.Append(choice)

   405

                            name = element_infos["name"]

   406

                            value = element_infos["value"]

   407

   408

                            staticbox = wx.StaticBox(self.ParamsEditor,

   409

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

   410

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

   411

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

   412

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

   413

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

   414

                        else:

   415

                            for choice in element_infos["type"]:

   416

                                combobox.Append(choice)

   417

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   418

                        if element_infos["value"] is None:

   419

                            combobox.SetStringSelection("")

   420

                        else:

   421

                            combobox.SetStringSelection(element_infos["value"])

   422

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

   423

   424

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

   425

                    scmin = -(2**31)

   426

                    scmax = 2**31-1

   427

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

   428

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

   429

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

   430

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

   431

                    spinctrl = wx.SpinCtrl(self.ParamsEditor,

   432

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

   433

                    spinctrl.SetRange(scmin, scmax)

   434

                    boxsizer.AddWindow(spinctrl)

   435

                    if element_infos["value"] is not None:

   436

                        spinctrl.SetValue(element_infos["value"])

   437

                    spinctrl.Bind(wx.EVT_SPINCTRL,

   438

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   439

                                  spinctrl)

   440

   441

                else:

   442

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

   443

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

   444

                        boxsizer.AddWindow(checkbox)

   445

                        if element_infos["value"] is not None:

   446

                            checkbox.SetValue(element_infos["value"])

   447

                        checkbox.Bind(wx.EVT_CHECKBOX,

   448

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path),

   449

                                      checkbox)

   450

   451

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

   452

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

   453

                            scmin = 0

   454

                        else:

   455

                            scmin = -(2**31)

   456

                        scmax = 2**31-1

   457

                        spinctrl = wx.SpinCtrl(self.ParamsEditor,

   458

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

   459

                        spinctrl.SetRange(scmin, scmax)

   460

                        boxsizer.AddWindow(spinctrl)

   461

                        if element_infos["value"] is not None:

   462

                            spinctrl.SetValue(element_infos["value"])

   463

                        spinctrl.Bind(wx.EVT_SPINCTRL,

   464

                                      self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   465

                                      spinctrl)

   466

   467

                    else:

   468

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

   469

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

   470

                                                        parent=self.ParamsEditor,

   471

                                                        choices=choices,

   472

                                                        element_path=element_path,

   473

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

   474

   475

                        boxsizer.AddWindow(textctrl)

   476

                        if element_infos["value"] is not None:

   477

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

   478

                        callback = self.GetTextCtrlCallBackFunction(textctrl, element_path)

   479

                        textctrl.Bind(wx.EVT_TEXT_ENTER, callback)

   480

                        textctrl.Bind(wx.EVT_KILL_FOCUS, callback)

   481

            first = False

   482

   483

   484

    def GetItemChannelChangedFunction(self, dir):

   485

        def OnConfNodeTreeItemChannelChanged(event):

   486

            confnode_IECChannel = self.Controler.BaseParams.getIEC_Channel()

   487

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

   488

            wx.CallAfter(self.RefreshIECChannelControlsState)

   489

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

   490

            event.Skip()

   491

        return OnConfNodeTreeItemChannelChanged

   492

   493

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

   494

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

   495

        if StructChanged and self.ParamsEditor is not None: