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 = {

    41

        'times': 'Times New Roman',

    42

        'mono':  'Courier New',

    43

        'helv':  'Arial',

    44

        'other': 'Comic Sans MS',

    45

        'size':  16,

    46

    }

    47

else:

    48

    faces = {

    49

        'times': 'Times',

    50

        'mono':  'Courier',

    51

        'helv':  'Helvetica',

    52

        'other': 'new century schoolbook',

    53

        'size':  18,

    54

    }

    55

    56

SCROLLBAR_UNIT = 10

    57

    58

    59

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

    60

    def _GetLabelSize(self):

    61

        """ used internally """

    62

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

    63

        if not self.bmpLabel:

    64

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

    65

    66

        w_bmp = self.bmpLabel.GetWidth()+2

    67

        h_bmp = self.bmpLabel.GetHeight()+2

    68

        height = h + h_bmp

    69

        if w_bmp > w:

    70

            width = w_bmp

    71

        else:

    72

            width = w

    73

        return width, height, False

    74

    75

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

    76

        bmp = self.bmpLabel

    77

        if bmp is not None:     # if the bitmap is used

    78

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

    79

                bmp = self.bmpDisabled

    80

            if self.bmpFocus and self.hasFocus:

    81

                bmp = self.bmpFocus

    82

            if self.bmpSelected and not self.up:

    83

                bmp = self.bmpSelected

    84

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

    85

            if not self.up:

    86

                dw = dy = self.labelDelta

    87

            hasMask = bmp.GetMask() is not None

    88

        else:

    89

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

    90

    91

        dc.SetFont(self.GetFont())

    92

        if self.IsEnabled():

    93

            dc.SetTextForeground(self.GetForegroundColour())

    94

        else:

    95

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

    96

    97

        label = self.GetLabel()

    98

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

    99

        if not self.up:

   100

            dw = dy = self.labelDelta

   101

   102

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

   103

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

   104

        if bmp is not None:

   105

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

   106

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

   107

            pos_y += bh + 2

   108

   109

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

   110

   111

   112

class GenStaticBitmap(wx.StaticBitmap):

   113

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

   114

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

   115

    def __init__(self, parent, ID, bitmapname,

   116

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

   117

                 style=0,

   118

                 name="genstatbmp"):

   119

   120

        bitmap = GetBitmap(bitmapname)

   121

        if bitmap is None:

   122

            bitmap = wx.EmptyBitmap(0, 0)

   123

   124

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

   125

                 bitmap,

   126

                 pos, size,

   127

                 style,

   128

                 name)

   129

   130

   131

class ConfTreeNodeEditor(EditorPanel):

   132

   133

    SHOW_BASE_PARAMS = True

   134

    SHOW_PARAMS = True

   135

    CONFNODEEDITOR_TABS = []

   136

   137

    def _init_Editor(self, parent):

   138

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   139

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

   140

            tabs_num += 1

   141

   142

        if tabs_num > 1 or self.SHOW_BASE_PARAMS:

   143

            self.Editor = wx.Panel(parent,

   144

                style=wx.SUNKEN_BORDER | wx.SP_3D)

   145

   146

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

   147

   148

            if self.SHOW_BASE_PARAMS:

   149

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   150

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

   151

                      flag=wx.GROW | wx.ALL)

   152

   153

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

   154

                self.FullIECChannel.SetFont(

   155

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

   156

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

   157

                baseparamseditor_sizer.AddWindow(self.FullIECChannel,

   158

                      flag=wx.ALIGN_CENTER_VERTICAL)

   159

   160

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   161

                baseparamseditor_sizer.AddSizer(updownsizer, border=5,

   162

                      flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL)

   163

   164

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

   165

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

   166

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

   167

                      self.IECCUpButton)

   168

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

   169

   170

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

   171

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

   172

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

   173

                      self.IECCDownButton)

   174

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

   175

   176

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

   177

                      size=wx.Size(150, 25))

   178

                self.ConfNodeName.SetFont(

   179

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

   180

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

   181

                self.ConfNodeName.Bind(wx.EVT_TEXT,

   182

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

   183

                      self.ConfNodeName)

   184

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

   185

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

   186

   187

                buttons_sizer = self.GenerateMethodButtonSizer()

   188

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

   189

   190

            if tabs_num > 1:

   191

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

   192

                parent = self.ConfNodeNoteBook

   193

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

   194

            else:

   195

                parent = self.Editor

   196

                self.ConfNodeNoteBook = None

   197

   198

            self.Editor.SetSizer(self.MainSizer)

   199

        else:

   200

            self.ConfNodeNoteBook = None

   201

            self.Editor = None

   202

   203

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   204

            editor = getattr(self, create_func_name)(parent)

   205

            if self.ConfNodeNoteBook is not None:

   206

                self.ConfNodeNoteBook.AddPage(editor, title)

   207

            elif self.SHOW_BASE_PARAMS:

   208

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

   209

            else:

   210

                self.Editor = editor

   211

   212

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

   213

   214

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

   215

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

   216

                panel_style |= wx.SUNKEN_BORDER

   217

            self.ParamsEditor = wx.ScrolledWindow(parent,

   218

                  style=panel_style)

   219

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

   220

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

   221

   222

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

   223

            self.ParamsEditorSizer.AddGrowableCol(0)

   224

            self.ParamsEditorSizer.AddGrowableRow(0)

   225

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   226

   227

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

   228

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

   229

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

   230

   231

            self.RefreshConfNodeParamsSizer()

   232

   233

            if self.ConfNodeNoteBook is not None:

   234

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

   235

            elif self.SHOW_BASE_PARAMS:

   236

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

   237

            else:

   238

                self.Editor = self.ParamsEditor

   239

        else:

   240

            self.ParamsEditor = None

   241

   242

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

   243

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

   244

   245

        icon_name = self.Controler.GetIconName()

   246

        if icon_name is not None:

   247

            self.SetIcon(GetBitmap(icon_name))

   248

        else:

   249

            self.SetIcon(GetBitmap("Extension"))

   250

   251

    def __del__(self):

   252

        self.Controler.OnCloseEditor(self)

   253

   254

    def GetTagName(self):

   255

        return self.Controler.CTNFullName()

   256

   257

    def GetTitle(self):

   258

        fullname = self.Controler.CTNFullName()

   259

        if self.Controler.CTNTestModified():

   260

            return "~%s~" % fullname

   261

        return fullname

   262

   263

    def HasNoModel(self):

   264

        return False

   265

   266

    def GetBufferState(self):

   267

        return False, False

   268

   269

    def Undo(self):

   270

        pass

   271

   272

    def Redo(self):

   273

        pass

   274

   275

    def RefreshView(self):

   276

        EditorPanel.RefreshView(self)

   277

        if self.SHOW_BASE_PARAMS:

   278

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

   279

            self.RefreshIECChannelControlsState()

   280

        if self.ParamsEditor is not None:

   281

            self.RefreshConfNodeParamsSizer()

   282

            self.RefreshScrollbars()

   283

   284

    def RefreshIECChannelControlsState(self):

   285

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

   286

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

   287

        self.MainSizer.Layout()

   288

   289

    def RefreshConfNodeParamsSizer(self):

   290

        self.Freeze()

   291

        self.ConfNodeParamsSizer.Clear(True)

   292

   293

        confnode_infos = self.Controler.GetParamsAttributes()

   294

        if len(confnode_infos) > 0:

   295

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

   296

   297

        self.ParamsEditorSizer.Layout()

   298

        self.Thaw()

   299

   300

    def GenerateMethodButtonSizer(self):

   301

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

   302

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

   303

   304

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   305

   306

        for confnode_method in self.Controler.ConfNodeMethods:

   307

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

   308

                button = GenBitmapTextButton(self.Editor,

   309

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

   310

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

   311

                button.SetFont(normal_bt_font)

   312

                button.SetToolTipString(confnode_method["tooltip"])

   313

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

   314

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

   315

                else:

   316

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

   317

                # a fancy underline on mouseover

   318

   319

                def setFontStyle(b, s):

   320

                    def fn(event):

   321

                        b.SetFont(s)

   322

                        b.Refresh()

   323

                        event.Skip()

   324

                    return fn

   325

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

   326

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

   327

                # hack to force size to mini

   328

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

   329

                    button.Disable()

   330

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

   331

        return msizer

   332

   333

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

   334

        if clean:

   335

            sizer.Clear(True)

   336

        first = True

   337

        for element_infos in elements:

   338

            if path:

   339

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

   340

            else:

   341

                element_path = element_infos["name"]

   342

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

   343

                name = element_infos["name"]

   344

                value = element_infos["value"]

   345

                label = _(name)

   346

                if value is not None:

   347

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

   348

                staticbox = wx.StaticBox(self.ParamsEditor,

   349

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

   350

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

   351

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

   352

                if first:

   353

                    flags |= wx.TOP

   354

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

   355

                self.GenerateSizerElements(staticboxsizer,

   356

                                           element_infos["children"],

   357

                                           element_path)

   358

            else:

   359

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

   360

                boxsizer.AddGrowableCol(1)

   361

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

   362

                if first:

   363

                    flags |= wx.TOP

   364

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

   365

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

   366

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

   367

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

   368

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

   369

   370

                statictext = wx.StaticText(self.ParamsEditor,

   371

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

   372

                boxsizer.AddWindow(statictext, border=5,

   373

                      flag=wx.ALIGN_CENTER_VERTICAL | wx.RIGHT)

   374

   375

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

   376

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

   377

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   378

                        boxsizer.AddSizer(browse_boxsizer)

   379

   380

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   381

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

   382

                        if element_infos["value"] is not None:

   383

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

   384

                            value_infos = element_infos["value"][1]

   385

                        else:

   386

                            value_infos = None

   387

                        browse_boxsizer.AddWindow(textctrl)

   388

   389

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

   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 | wx.LEFT | wx.RIGHT)

   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

        sizer.Layout()

   483

        self.RefreshScrollbars()

   484

   485

    def GetItemChannelChangedFunction(self, dir):

   486

        def OnConfNodeTreeItemChannelChanged(event):

   487

            confnode_IECChannel = self.Controler.BaseParams.getIEC_Channel()

   488

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

   489

            wx.CallAfter(self.RefreshIECChannelControlsState)

   490

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

   491

            event.Skip()

   492

        return OnConfNodeTreeItemChannelChanged