1

     2

import os

     3

import types

     4

     5

import wx

     6

     7

from EditorPanel import EditorPanel

     8

     9

from IDEFrame import TITLE, FILEMENU, PROJECTTREE, PAGETITLES

    10

    11

from controls import TextCtrlAutoComplete

    12

from dialogs import BrowseValuesLibraryDialog

    13

from util.BitmapLibrary import GetBitmap

    14

    15

if wx.Platform == '__WXMSW__':

    16

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

    17

              'mono' : 'Courier New',

    18

              'helv' : 'Arial',

    19

              'other': 'Comic Sans MS',

    20

              'size' : 16,

    21

             }

    22

else:

    23

    faces = { 'times': 'Times',

    24

              'mono' : 'Courier',

    25

              'helv' : 'Helvetica',

    26

              'other': 'new century schoolbook',

    27

              'size' : 18,

    28

             }

    29

    30

SCROLLBAR_UNIT = 10

    31

    32

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

    33

    34

def Bpath(*args):

    35

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

    36

    37

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

    38

    def _GetLabelSize(self):

    39

        """ used internally """

    40

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

    41

        if not self.bmpLabel:

    42

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

    43

    44

        w_bmp = self.bmpLabel.GetWidth()+2

    45

        h_bmp = self.bmpLabel.GetHeight()+2

    46

        height = h + h_bmp

    47

        if w_bmp > w:

    48

            width = w_bmp

    49

        else:

    50

            width = w

    51

        return width, height, False

    52

    53

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

    54

        bmp = self.bmpLabel

    55

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

    56

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

    57

                bmp = self.bmpDisabled

    58

            if self.bmpFocus and self.hasFocus:

    59

                bmp = self.bmpFocus

    60

            if self.bmpSelected and not self.up:

    61

                bmp = self.bmpSelected

    62

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

    63

            if not self.up:

    64

                dw = dy = self.labelDelta

    65

            hasMask = bmp.GetMask() != None

    66

        else:

    67

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

    68

    69

        dc.SetFont(self.GetFont())

    70

        if self.IsEnabled():

    71

            dc.SetTextForeground(self.GetForegroundColour())

    72

        else:

    73

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

    74

    75

        label = self.GetLabel()

    76

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

    77

        if not self.up:

    78

            dw = dy = self.labelDelta

    79

    80

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

    81

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

    82

        if bmp !=None:

    83

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

    84

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

    85

            pos_y += bh + 2

    86

    87

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

    88

    89

    90

class GenStaticBitmap(wx.StaticBitmap):

    91

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

    92

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

    93

    def __init__(self, parent, ID, bitmapname,

    94

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

    95

                 style = 0,

    96

                 name = "genstatbmp"):

    97

    98

        bitmap = GetBitmap(bitmapname)

    99

        if bitmap is None:

   100

            bitmap = wx.EmptyBitmap(0, 0)

   101

   102

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

   103

                 bitmap,

   104

                 pos, size,

   105

                 style,

   106

                 name)

   107

   108

class ConfTreeNodeEditor(EditorPanel):

   109

   110

    SHOW_BASE_PARAMS = True

   111

    SHOW_PARAMS = True

   112

    CONFNODEEDITOR_TABS = []

   113

   114

    def _init_Editor(self, parent):

   115

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   116

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

   117

            tabs_num += 1

   118

   119

        if tabs_num > 1 or self.SHOW_BASE_PARAMS:

   120

            self.Editor = wx.Panel(parent, 

   121

                style=wx.SUNKEN_BORDER|wx.SP_3D)

   122

   123

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

   124

   125

            if self.SHOW_BASE_PARAMS:

   126

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   127

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

   128

                      flag=wx.GROW|wx.ALL)

   129

   130

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

   131

                self.FullIECChannel.SetFont(

   132

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

   133

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

   134

                baseparamseditor_sizer.AddWindow(self.FullIECChannel, 

   135

                      flag=wx.ALIGN_CENTER_VERTICAL)

   136

   137

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   138

                baseparamseditor_sizer.AddSizer(updownsizer, border=5, 

   139

                      flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL)

   140

   141

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

   142

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

   143

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

   144

                      self.IECCUpButton)

   145

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

   146

   147

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

   148

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

   149

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

   150

                      self.IECCDownButton)

   151

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

   152

   153

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

   154

                      size=wx.Size(150, 25))

   155

                self.ConfNodeName.SetFont(

   156

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

   157

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

   158

                self.ConfNodeName.Bind(wx.EVT_TEXT, 

   159

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

   160

                      self.ConfNodeName)

   161

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

   162

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

   163

   164

                buttons_sizer = self.GenerateMethodButtonSizer()

   165

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

   166

   167

            if tabs_num > 1:

   168

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

   169

                parent = self.ConfNodeNoteBook

   170

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

   171

            else:

   172

                parent = self.Editor

   173

                self.ConfNodeNoteBook = None

   174

   175

            self.Editor.SetSizer(self.MainSizer)

   176

        else:

   177

            self.ConfNodeNoteBook = None

   178

            self.Editor = None

   179

   180

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   181

            editor = getattr(self, create_func_name)(parent)

   182

            if self.ConfNodeNoteBook is not None:

   183

                self.ConfNodeNoteBook.AddPage(editor, title)

   184

            elif self.SHOW_BASE_PARAMS:

   185

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

   186

            else:

   187

                self.Editor = editor

   188

   189

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

   190

   191

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

   192

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

   193

                panel_style |= wx.SUNKEN_BORDER

   194

            self.ParamsEditor = wx.ScrolledWindow(parent, 

   195

                  style=panel_style)

   196

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

   197

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

   198

   199

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

   200

            self.ParamsEditorSizer.AddGrowableCol(0)

   201

            self.ParamsEditorSizer.AddGrowableRow(0)

   202

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   203

   204

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

   205

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

   206

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

   207

   208

            self.RefreshConfNodeParamsSizer()

   209

   210

            if self.ConfNodeNoteBook is not None:

   211

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

   212

            elif self.SHOW_BASE_PARAMS:

   213

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

   214

            else:

   215

                self.Editor = self.ParamsEditor

   216

        else:

   217

            self.ParamsEditor = None

   218

   219

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

   220

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

   221

   222

        icon_name = self.Controler.GetIconName()

   223

        if icon_name is not None:

   224

            self.SetIcon(GetBitmap(icon_name))

   225

        else:

   226

            self.SetIcon(GetBitmap("Extension"))

   227

   228

    def __del__(self):

   229

        self.Controler.OnCloseEditor(self)

   230

   231

    def GetTagName(self):

   232

        return self.Controler.CTNFullName()

   233

   234

    def GetTitle(self):

   235

        fullname = self.Controler.CTNFullName()

   236

        if self.Controler.CTNTestModified():

   237

            return "~%s~" % fullname

   238

        return fullname

   239

   240

    def HasNoModel(self):

   241

        return False

   242

   243

    def GetBufferState(self):

   244

        return False, False

   245

   246

    def Undo(self):

   247

        pass

   248

   249

    def Redo(self):

   250

        pass

   251

   252

    def RefreshView(self):

   253

        EditorPanel.RefreshView(self)

   254

        if self.SHOW_BASE_PARAMS:

   255

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

   256

            self.RefreshIECChannelControlsState()

   257

        if self.ParamsEditor is not None:

   258

            self.RefreshConfNodeParamsSizer()

   259

            self.RefreshScrollbars()

   260

   261

    def RefreshIECChannelControlsState(self):

   262

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

   263

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

   264

        self.MainSizer.Layout()

   265

   266

    def RefreshConfNodeParamsSizer(self):

   267

        self.Freeze()

   268

        self.ConfNodeParamsSizer.Clear(True)

   269

   270

        confnode_infos = self.Controler.GetParamsAttributes()

   271

        if len(confnode_infos) > 0:

   272

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

   273

   274

        self.ParamsEditorSizer.Layout()

   275

        self.Thaw()

   276

   277

    def GenerateMethodButtonSizer(self):

   278

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

   279

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

   280

   281

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   282

   283

        for confnode_method in self.Controler.ConfNodeMethods:

   284

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

   285

                button = GenBitmapTextButton(self.Editor,

   286

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

   287

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

   288

                button.SetFont(normal_bt_font)

   289

                button.SetToolTipString(confnode_method["tooltip"])

   290

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

   291

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

   292

                else:

   293

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

   294

                # a fancy underline on mouseover

   295

                def setFontStyle(b, s):

   296

                    def fn(event):

   297

                        b.SetFont(s)

   298

                        b.Refresh()

   299

                        event.Skip()

   300

                    return fn

   301

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

   302

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

   303

                #hack to force size to mini

   304

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

   305

                    button.Disable()

   306

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

   307

        return msizer

   308

   309

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

   310

        if clean:

   311

            sizer.Clear(True)

   312

        first = True

   313

        for element_infos in elements:

   314

            if path:

   315

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

   316

            else:

   317

                element_path = element_infos["name"]

   318

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

   319

                name = element_infos["name"]

   320

                value = element_infos["value"]

   321

                label = _(name)

   322

                if value is not None:

   323

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

   324

                staticbox = wx.StaticBox(self.ParamsEditor, 

   325

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

   326

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

   327

                if first:

   328

                    sizer.AddSizer(staticboxsizer, border=5, 

   329

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

   330

                else:

   331

                    sizer.AddSizer(staticboxsizer, border=5, 

   332

                          flag=wx.GROW|wx.BOTTOM)

   333

                self.GenerateSizerElements(staticboxsizer, 

   334

                                           element_infos["children"], 

   335

                                           element_path)

   336

            else:

   337

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

   338

                boxsizer.AddGrowableCol(1)

   339

                if first:

   340

                    sizer.AddSizer(boxsizer, border=5, 

   341

                          flag=wx.GROW|wx.ALL)

   342

                else:

   343

                    sizer.AddSizer(boxsizer, border=5, 

   344

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

   345

   346

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

   347

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

   348

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

   349

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

   350

   351

                statictext = wx.StaticText(self.ParamsEditor, 

   352

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

   353

                boxsizer.AddWindow(statictext, border=5, 

   354

                      flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT)

   355

   356

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

   357

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

   358

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   359

                        boxsizer.AddSizer(browse_boxsizer)

   360

   361

                        textctrl = wx.TextCtrl(self.ParamsEditor, 

   362

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

   363

                        if element_infos["value"] is not None:

   364

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

   365

                            value_infos = element_infos["value"][1]

   366

                        else:

   367

                            value_infos = None

   368

                        browse_boxsizer.AddWindow(textctrl)

   369

   370

                        button = wx.Button(self.ParamsEditor, 

   371

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

   372

                        browse_boxsizer.AddWindow(button)

   373

                        button.Bind(wx.EVT_BUTTON, 

   374

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

   375

                                                                   value_infos, element_path), 

   376

                                    button)

   377

                    else:

   378

                        combobox = wx.ComboBox(self.ParamsEditor, 

   379

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

   380

                        boxsizer.AddWindow(combobox)

   381

   382

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

   383

                            combobox.Append("")

   384

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

   385

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

   386

                                combobox.Append(choice)

   387

                            name = element_infos["name"]

   388

                            value = element_infos["value"]

   389

   390

                            staticbox = wx.StaticBox(self.ParamsEditor, 

   391

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

   392

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

   393

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

   394

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

   395

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

   396

                        else:

   397

                            for choice in element_infos["type"]:

   398

                                combobox.Append(choice)

   399

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   400

                        if element_infos["value"] is None:

   401

                            combobox.SetStringSelection("")

   402

                        else:

   403

                            combobox.SetStringSelection(element_infos["value"])

   404

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

   405

   406

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

   407

                    scmin = -(2**31)

   408

                    scmax = 2**31-1

   409

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

   410

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

   411

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

   412

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

   413

                    spinctrl = wx.SpinCtrl(self.ParamsEditor, 

   414

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

   415

                    spinctrl.SetRange(scmin, scmax)

   416

                    boxsizer.AddWindow(spinctrl)

   417

                    if element_infos["value"] is not None:

   418

                        spinctrl.SetValue(element_infos["value"])

   419

                    spinctrl.Bind(wx.EVT_SPINCTRL, 

   420

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   421

                                  spinctrl)

   422

   423

                else:

   424

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

   425

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

   426

                        boxsizer.AddWindow(checkbox)

   427

                        if element_infos["value"] is not None:

   428

                            checkbox.SetValue(element_infos["value"])

   429

                        checkbox.Bind(wx.EVT_CHECKBOX, 

   430

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path), 

   431

                                      checkbox)

   432

   433

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

   434

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

   435

                            scmin = 0

   436

                        else:

   437

                            scmin = -(2**31)

   438

                        scmax = 2**31-1

   439

                        spinctrl = wx.SpinCtrl(self.ParamsEditor, 

   440

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

   441

                        spinctrl.SetRange(scmin, scmax)

   442

                        boxsizer.AddWindow(spinctrl)

   443

                        if element_infos["value"] is not None:

   444

                            spinctrl.SetValue(element_infos["value"])

   445

                        spinctrl.Bind(wx.EVT_SPINCTRL, 

   446

                                      self.GetTextCtrlCallBackFunction(spinctrl, element_path), 

   447

                                      spinctrl)

   448

   449

                    else:

   450

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

   451

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

   452

                                                        parent=self.ParamsEditor, 

   453

                                                        choices=choices, 

   454

                                                        element_path=element_path,

   455

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

   456

   457

                        boxsizer.AddWindow(textctrl)

   458

                        if element_infos["value"] is not None:

   459

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

   460

                        callback = self.GetTextCtrlCallBackFunction(textctrl, element_path)

   461

                        textctrl.Bind(wx.EVT_TEXT_ENTER, callback)

   462

                        textctrl.Bind(wx.EVT_KILL_FOCUS, callback)

   463

            first = False

   464

   465

   466

    def GetItemChannelChangedFunction(self, dir):

   467

        def OnConfNodeTreeItemChannelChanged(event):

   468

            confnode_IECChannel = self.Controler.BaseParams.getIEC_Channel()

   469

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

   470

            wx.CallAfter(self.RefreshIECChannelControlsState)

   471

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

   472

            event.Skip()

   473

        return OnConfNodeTreeItemChannelChanged

   474

   475

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

   476

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

   477

        if StructChanged and self.ParamsEditor is not None:

   478

            wx.CallAfter(self.RefreshConfNodeParamsSizer)

   479

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

   480

        return res

   481

   482

    def GetButtonCallBackFunction(self, method, push=False):

   483

        """ Generate the callbackfunc for a given confnode method"""

   484

        def OnButtonClick(event):

   485

            # Disable button to prevent re-entrant call 

   486

            event.GetEventObject().Disable()

   487

            # Call

   488

            getattr(self.Controler,method)()

   489

            # Re-enable button 

   490

            event.GetEventObject().Enable()

   491

   492

            if not push:

   493

                event.Skip()

   494

        return OnButtonClick

   495

   496

    def GetChoiceCallBackFunction(self, choicectrl, path):

   497

        def OnChoiceChanged(event):

   498

            res = self.SetConfNodeParamsAttribute(path, choicectrl.GetStringSelection())

   499

            choicectrl.SetStringSelection(res)

   500

            event.Skip()

   501

        return OnChoiceChanged

   502

   503

    def GetChoiceContentCallBackFunction(self, choicectrl, staticboxsizer, path):

   504

        def OnChoiceContentChanged(event):

   505