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

    57

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

    58

    def _GetLabelSize(self):

    59

        """ used internally """

    60

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

    61

        if not self.bmpLabel:

    62

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

    63

    64

        w_bmp = self.bmpLabel.GetWidth()+2

    65

        h_bmp = self.bmpLabel.GetHeight()+2

    66

        height = h + h_bmp

    67

        if w_bmp > w:

    68

            width = w_bmp

    69

        else:

    70

            width = w

    71

        return width, height, False

    72

    73

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

    74

        bmp = self.bmpLabel

    75

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

    76

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

    77

                bmp = self.bmpDisabled

    78

            if self.bmpFocus and self.hasFocus:

    79

                bmp = self.bmpFocus

    80

            if self.bmpSelected and not self.up:

    81

                bmp = self.bmpSelected

    82

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

    83

            if not self.up:

    84

                dw = dy = self.labelDelta

    85

            hasMask = bmp.GetMask() is not None

    86

        else:

    87

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

    88

    89

        dc.SetFont(self.GetFont())

    90

        if self.IsEnabled():

    91

            dc.SetTextForeground(self.GetForegroundColour())

    92

        else:

    93

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

    94

    95

        label = self.GetLabel()

    96

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

    97

        if not self.up:

    98

            dw = dy = self.labelDelta

    99

   100

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

   101

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

   102

        if bmp is not None:

   103

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

   104

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

   105

            pos_y += bh + 2

   106

   107

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

   108

   109

   110

class GenStaticBitmap(wx.StaticBitmap):

   111

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

   112

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

   113

    def __init__(self, parent, ID, bitmapname,

   117

   118

        bitmap = GetBitmap(bitmapname)

   119

        if bitmap is None:

   120

            bitmap = wx.EmptyBitmap(0, 0)

   121

   122

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

   123

                 bitmap,

   124

                 pos, size,

   125

                 style,

   126

                 name)

   127

   128

   129

class ConfTreeNodeEditor(EditorPanel):

   130

   131

    SHOW_BASE_PARAMS = True

   132

    SHOW_PARAMS = True

   133

    CONFNODEEDITOR_TABS = []

   134

   135

    def _init_Editor(self, parent):

   136

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   137

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

   138

            tabs_num += 1

   139

   140

        if tabs_num > 1 or self.SHOW_BASE_PARAMS:

   141

            self.Editor = wx.Panel(parent,

   142

                style=wx.SUNKEN_BORDER|wx.SP_3D)

   143

   144

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

   145

   146

            if self.SHOW_BASE_PARAMS:

   147

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   148

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

   149

                      flag=wx.GROW|wx.ALL)

   150

   151

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

   152

                self.FullIECChannel.SetFont(

   153

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

   155

                baseparamseditor_sizer.AddWindow(self.FullIECChannel,

   156

                      flag=wx.ALIGN_CENTER_VERTICAL)

   157

   158

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   159

                baseparamseditor_sizer.AddSizer(updownsizer, border=5,

   160

                      flag=wx.LEFT|wx.ALIGN_CENTER_VERTICAL)

   161

   162

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

   163

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

   164

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

   165

                      self.IECCUpButton)

   166

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

   167

   168

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

   169

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

   170

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

   171

                      self.IECCDownButton)

   172

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

   173

   174

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

   175

                      size=wx.Size(150, 25))

   176

                self.ConfNodeName.SetFont(

   177

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

   179

                self.ConfNodeName.Bind(wx.EVT_TEXT,

   180

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

   181

                      self.ConfNodeName)

   182

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

   183

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

   184

   185

                buttons_sizer = self.GenerateMethodButtonSizer()

   186

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

   187

   188

            if tabs_num > 1:

   189

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

   190

                parent = self.ConfNodeNoteBook

   191

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

   192

            else:

   193

                parent = self.Editor

   194

                self.ConfNodeNoteBook = None

   195

   196

            self.Editor.SetSizer(self.MainSizer)

   197

        else:

   198

            self.ConfNodeNoteBook = None

   199

            self.Editor = None

   200

   201

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   202

            editor = getattr(self, create_func_name)(parent)

   203

            if self.ConfNodeNoteBook is not None:

   204

                self.ConfNodeNoteBook.AddPage(editor, title)

   205

            elif self.SHOW_BASE_PARAMS:

   206

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

   207

            else:

   208

                self.Editor = editor

   209

   210

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

   211

   212

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

   213

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

   214

                panel_style |= wx.SUNKEN_BORDER

   215

            self.ParamsEditor = wx.ScrolledWindow(parent,

   216

                  style=panel_style)

   217

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

   218

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

   219

   220

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

   221

            self.ParamsEditorSizer.AddGrowableCol(0)

   222

            self.ParamsEditorSizer.AddGrowableRow(0)

   223

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   224

   225

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

   226

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

   227

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

   228

   229

            self.RefreshConfNodeParamsSizer()

   230

   231

            if self.ConfNodeNoteBook is not None:

   232

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

   233

            elif self.SHOW_BASE_PARAMS:

   234

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

   235

            else:

   236

                self.Editor = self.ParamsEditor

   237

        else:

   238

            self.ParamsEditor = None

   239

   240

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

   241

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

   242

   243

        icon_name = self.Controler.GetIconName()

   244

        if icon_name is not None:

   245

            self.SetIcon(GetBitmap(icon_name))

   246

        else:

   247

            self.SetIcon(GetBitmap("Extension"))

   248

   249

    def __del__(self):

   250

        self.Controler.OnCloseEditor(self)

   251

   252

    def GetTagName(self):

   253

        return self.Controler.CTNFullName()

   254

   255

    def GetTitle(self):

   256

        fullname = self.Controler.CTNFullName()

   257

        if self.Controler.CTNTestModified():

   258

            return "~%s~" % fullname

   259

        return fullname

   260

   261

    def HasNoModel(self):

   262

        return False

   263

   264

    def GetBufferState(self):

   265

        return False, False

   266

   267

    def Undo(self):

   268

        pass

   269

   270

    def Redo(self):

   271

        pass

   272

   273

    def RefreshView(self):

   274

        EditorPanel.RefreshView(self)

   275

        if self.SHOW_BASE_PARAMS:

   276

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

   277

            self.RefreshIECChannelControlsState()

   278

        if self.ParamsEditor is not None:

   279

            self.RefreshConfNodeParamsSizer()

   280

            self.RefreshScrollbars()

   281

   282

    def RefreshIECChannelControlsState(self):

   283

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

   284

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

   285

        self.MainSizer.Layout()

   286

   287

    def RefreshConfNodeParamsSizer(self):

   288

        self.Freeze()

   289

        self.ConfNodeParamsSizer.Clear(True)

   290

   291

        confnode_infos = self.Controler.GetParamsAttributes()

   292

        if len(confnode_infos) > 0:

   293

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

   294

   295

        self.ParamsEditorSizer.Layout()

   296

        self.Thaw()

   297

   298

    def GenerateMethodButtonSizer(self):

   301

   302

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   303

   304

        for confnode_method in self.Controler.ConfNodeMethods:

   305

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

   306

                button = GenBitmapTextButton(self.Editor,

   307

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

   308

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

   309

                button.SetFont(normal_bt_font)

   310

                button.SetToolTipString(confnode_method["tooltip"])

   311

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

   312

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

   313

                else:

   314

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

   315

                # a fancy underline on mouseover

   316

                def setFontStyle(b, s):

   317

                    def fn(event):

   318

                        b.SetFont(s)

   319

                        b.Refresh()

   320

                        event.Skip()

   321

                    return fn

   322

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

   323

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

   324

                # hack to force size to mini

   325

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

   326

                    button.Disable()

   327

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

   328

        return msizer

   329

   331

        if clean:

   332

            sizer.Clear(True)

   333

        first = True

   334

        for element_infos in elements:

   335

            if path:

   336

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

   337

            else:

   338

                element_path = element_infos["name"]

   339

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

   340

                name = element_infos["name"]

   341

                value = element_infos["value"]

   342

                label = _(name)

   343

                if value is not None:

   344

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

   345

                staticbox = wx.StaticBox(self.ParamsEditor,

   346

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

   347

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

   348

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

   349

                if first:

   350

                    flags |= wx.TOP

   351

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

   352

                self.GenerateSizerElements(staticboxsizer,

   353

                                           element_infos["children"],

   354

                                           element_path)

   355

            else:

   356

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

   357

                boxsizer.AddGrowableCol(1)

   358

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

   359

                if first:

   360

                    flags |= wx.TOP

   361

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

   362

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

   363

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

   364

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

   365

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

   366

   367

                statictext = wx.StaticText(self.ParamsEditor,

   368

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

   369

                boxsizer.AddWindow(statictext, border=5,

   370

                      flag=wx.ALIGN_CENTER_VERTICAL|wx.RIGHT)

   371

   372

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

   373

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

   374

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   375

                        boxsizer.AddSizer(browse_boxsizer)

   376

   377

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   378

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

   379

                        if element_infos["value"] is not None:

   380

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

   381

                            value_infos = element_infos["value"][1]

   382

                        else:

   383

                            value_infos = None

   384

                        browse_boxsizer.AddWindow(textctrl)

   385

   386

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

   387

                        browse_boxsizer.AddWindow(button)

   388

                        button.Bind(wx.EVT_BUTTON,

   389

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

   390

                                                                   value_infos, element_path),

   391

                                    button)

   392

                    else:

   393

                        combobox = wx.ComboBox(self.ParamsEditor,

   394

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

   395

                        boxsizer.AddWindow(combobox)

   396

   397

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

   398

                            combobox.Append("")

   399

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

   400

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

   401

                                combobox.Append(choice)

   402

                            name = element_infos["name"]

   403

                            value = element_infos["value"]

   404

   405

                            staticbox = wx.StaticBox(self.ParamsEditor,

   406

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

   407

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

   408

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

   409

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

   410

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

   411

                        else:

   412

                            for choice in element_infos["type"]:

   413

                                combobox.Append(choice)

   414

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   415

                        if element_infos["value"] is None:

   416

                            combobox.SetStringSelection("")

   417

                        else:

   418

                            combobox.SetStringSelection(element_infos["value"])

   419

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

   420

   421

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

   422

                    scmin = -(2**31)

   423

                    scmax = 2**31-1

   424

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

   425

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

   426

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

   427

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

   428

                    spinctrl = wx.SpinCtrl(self.ParamsEditor,

   429

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

   430

                    spinctrl.SetRange(scmin, scmax)

   431

                    boxsizer.AddWindow(spinctrl)

   432

                    if element_infos["value"] is not None:

   433

                        spinctrl.SetValue(element_infos["value"])

   434

                    spinctrl.Bind(wx.EVT_SPINCTRL,

   435

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   436

                                  spinctrl)

   437

   438

                else:

   439

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

   440

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

   441

                        boxsizer.AddWindow(checkbox)

   442

                        if element_infos["value"] is not None:

   443

                            checkbox.SetValue(element_infos["value"])

   444

                        checkbox.Bind(wx.EVT_CHECKBOX,

   445

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path),

   446

                                      checkbox)

   447

   448

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

   449

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

   450

                            scmin = 0

   451

                        else:

   452

                            scmin = -(2**31)

   453

                        scmax = 2**31-1

   454

                        spinctrl = wx.SpinCtrl(self.ParamsEditor,

   455

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

   456

                        spinctrl.SetRange(scmin, scmax)

   457

                        boxsizer.AddWindow(spinctrl)

   458

                        if element_infos["value"] is not None:

   459

                            spinctrl.SetValue(element_infos["value"])

   460

                        spinctrl.Bind(wx.EVT_SPINCTRL,

   461

                                      self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   462

                                      spinctrl)

   463

   464

                    else:

   465

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

   466

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

   467

                                                        parent=self.ParamsEditor,

   468

                                                        choices=choices,

   469

                                                        element_path=element_path,

   470

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

   471

   472

                        boxsizer.AddWindow(textctrl)

   473

                        if element_infos["value"] is not None:

   474

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

   475

                        callback = self.GetTextCtrlCallBackFunction(textctrl, element_path)

   476

                        textctrl.Bind(wx.EVT_TEXT_ENTER, callback)

   477

                        textctrl.Bind(wx.EVT_KILL_FOCUS, callback)

   478

            first = False

   479

        sizer.Layout()

   480

        self.RefreshScrollbars()

   481

   482

    def GetItemChannelChangedFunction(self, dir):

   483

        def OnConfNodeTreeItemChannelChanged(event):

   484

            confnode_IECChannel = self.Controler.BaseParams.getIEC_Channel()

   485

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

   486

            wx.CallAfter(self.RefreshIECChannelControlsState)

   487

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

   488

            event.Skip()

   489

        return OnConfNodeTreeItemChannelChanged

   490

   491

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

   492

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