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

    40

        'times': 'Times New Roman',

    41

        'mono':  'Courier New',

    42

        'helv':  'Arial',

    43

        'other': 'Comic Sans MS',

    44

        'size':  16,

    45

    }

    46

else:

    47

    faces = {

    48

        'times': 'Times',

    49

        'mono':  'Courier',

    50

        'helv':  'Helvetica',

    51

        'other': 'new century schoolbook',

    52

        'size':  18,

    53

    }

    54

    55

SCROLLBAR_UNIT = 10

    56

    57

    58

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

    59

    def _GetLabelSize(self):

    60

        """ used internally """

    61

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

    62

        if not self.bmpLabel:

    63

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

    64

    65

        w_bmp = self.bmpLabel.GetWidth()+2

    66

        h_bmp = self.bmpLabel.GetHeight()+2

    67

        height = h + h_bmp

    68

        if w_bmp > w:

    69

            width = w_bmp

    70

        else:

    71

            width = w

    72

        return width, height, False

    73

    74

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

    75

        bmp = self.bmpLabel

    76

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

    77

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

    78

                bmp = self.bmpDisabled

    79

            if self.bmpFocus and self.hasFocus:

    80

                bmp = self.bmpFocus

    81

            if self.bmpSelected and not self.up:

    82

                bmp = self.bmpSelected

    83

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

    84

            if not self.up:

    85

                dw = dy = self.labelDelta

    86

            hasMask = bmp.GetMask() is not None

    87

        else:

    88

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

    89

    90

        dc.SetFont(self.GetFont())

    91

        if self.IsEnabled():

    92

            dc.SetTextForeground(self.GetForegroundColour())

    93

        else:

    94

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

    95

    96

        label = self.GetLabel()

    97

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

    98

        if not self.up:

    99

            dw = dy = self.labelDelta

   100

   101

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

   102

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

   103

        if bmp is not None:

   104

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

   105

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

   106

            pos_y += bh + 2

   107

   108

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

   109

   110

   111

class GenStaticBitmap(wx.StaticBitmap):

   112

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

   113

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

   114

    def __init__(self, parent, ID, bitmapname,

   115

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

   116

                 style=0,

   117

                 name="genstatbmp"):

   118

   119

        bitmap = GetBitmap(bitmapname)

   120

        if bitmap is None:

   121

            bitmap = wx.EmptyBitmap(0, 0)

   122

   123

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

   124

                                 bitmap,

   125

                                 pos, size,

   126

                                 style,

   127

                                 name)

   128

   129

   130

class ConfTreeNodeEditor(EditorPanel):

   131

   132

    SHOW_BASE_PARAMS = True

   133

    SHOW_PARAMS = True

   134

    CONFNODEEDITOR_TABS = []

   135

   136

    def _init_Editor(self, parent):

   137

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   138

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

   139

            tabs_num += 1

   140

   141

        if tabs_num > 1 or self.SHOW_BASE_PARAMS:

   142

            self.Editor = wx.Panel(parent,

   143

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   144

   145

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

   146

   147

            if self.SHOW_BASE_PARAMS:

   148

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   149

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

   150

                                        flag=wx.GROW | wx.ALL)

   151

   152

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

   153

                self.FullIECChannel.SetFont(

   154

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

   155

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

   156

                baseparamseditor_sizer.AddWindow(self.FullIECChannel,

   157

                                                 flag=wx.ALIGN_CENTER_VERTICAL)

   158

   159

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   160

                baseparamseditor_sizer.AddSizer(updownsizer, border=5,

   161

                                                flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL)

   162

   163

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

   164

                    self.Editor,

   165

                    bitmap=GetBitmap('IECCDown'),

   166

                    size=wx.Size(16, 16),

   167

                    style=wx.NO_BORDER)

   168

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

   169

                                       self.IECCUpButton)

   170

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

   171

   172

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

   173

                    self.Editor, bitmap=GetBitmap('IECCUp'),

   174

                    size=wx.Size(16, 16), style=wx.NO_BORDER)

   175

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

   176

                                         self.IECCDownButton)

   177

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

   178

   179

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

   180

                                                size=wx.Size(150, 25))

   181

                self.ConfNodeName.SetFont(

   182

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

   183

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

   184

                self.ConfNodeName.Bind(

   185

                    wx.EVT_TEXT,

   186

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

   187

                    self.ConfNodeName)

   188

                baseparamseditor_sizer.AddWindow(

   189

                    self.ConfNodeName, border=5,

   190

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

   191

   192

                buttons_sizer = self.GenerateMethodButtonSizer()

   193

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

   194

   195

            if tabs_num > 1:

   196

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

   197

                parent = self.ConfNodeNoteBook

   198

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

   199

            else:

   200

                parent = self.Editor

   201

                self.ConfNodeNoteBook = None

   202

   203

            self.Editor.SetSizer(self.MainSizer)

   204

        else:

   205

            self.ConfNodeNoteBook = None

   206

            self.Editor = None

   207

   208

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   209

            editor = getattr(self, create_func_name)(parent)

   210

            if self.ConfNodeNoteBook is not None:

   211

                self.ConfNodeNoteBook.AddPage(editor, title)

   212

            elif self.SHOW_BASE_PARAMS:

   213

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

   214

            else:

   215

                self.Editor = editor

   216

   217

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

   218

   219

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

   220

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

   221

                panel_style |= wx.SUNKEN_BORDER

   222

            self.ParamsEditor = wx.ScrolledWindow(parent,

   223

                                                  style=panel_style)

   224

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

   225

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

   226

   227

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

   228

            self.ParamsEditorSizer.AddGrowableCol(0)

   229

            self.ParamsEditorSizer.AddGrowableRow(0)

   230

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   231

   232

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

   233

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

   234

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

   235

   236

            self.RefreshConfNodeParamsSizer()

   237

   238

            if self.ConfNodeNoteBook is not None:

   239

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

   240

            elif self.SHOW_BASE_PARAMS:

   241

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

   242

            else:

   243

                self.Editor = self.ParamsEditor

   244

        else:

   245

            self.ParamsEditor = None

   246

   247

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

   248

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

   249

   250

        icon_name = self.Controler.GetIconName()

   251

        if icon_name is not None:

   252

            self.SetIcon(GetBitmap(icon_name))

   253

        else:

   254

            self.SetIcon(GetBitmap("Extension"))

   255

   256

    def __del__(self):

   257

        self.Controler.OnCloseEditor(self)

   258

   259

    def GetTagName(self):

   260

        return self.Controler.CTNFullName()

   261

   262

    def GetTitle(self):

   263

        fullname = self.Controler.CTNFullName()

   264

        if self.Controler.CTNTestModified():

   265

            return "~%s~" % fullname

   266

        return fullname

   267

   268

    def HasNoModel(self):

   269

        return False

   270

   271

    def GetBufferState(self):

   272

        return False, False

   273

   274

    def Undo(self):

   275

        pass

   276

   277

    def Redo(self):

   278

        pass

   279

   280

    def RefreshView(self):

   281

        EditorPanel.RefreshView(self)

   282

        if self.SHOW_BASE_PARAMS:

   283

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

   284

            self.RefreshIECChannelControlsState()

   285

        if self.ParamsEditor is not None:

   286

            self.RefreshConfNodeParamsSizer()

   287

            self.RefreshScrollbars()

   288

   289

    def RefreshIECChannelControlsState(self):

   290

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

   291

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

   292

        self.MainSizer.Layout()

   293

   294

    def RefreshConfNodeParamsSizer(self):

   295

        self.Freeze()

   296

        self.ConfNodeParamsSizer.Clear(True)

   297

   298

        confnode_infos = self.Controler.GetParamsAttributes()

   299

        if len(confnode_infos) > 0:

   300

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

   301

   302

        self.ParamsEditorSizer.Layout()

   303

        self.Thaw()

   304

   305

    def GenerateMethodButtonSizer(self):

   306

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

   307

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

   308

   309

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   310

   311

        for confnode_method in self.Controler.ConfNodeMethods:

   312

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

   313

                button = GenBitmapTextButton(self.Editor,

   314

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

   315

                                             label=confnode_method["name"],

   316

                                             style=wx.NO_BORDER)

   317

                button.SetFont(normal_bt_font)

   318

                button.SetToolTipString(confnode_method["tooltip"])

   319

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

   320

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

   321

                else:

   322

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

   323

                # a fancy underline on mouseover

   324

   325

                def setFontStyle(b, s):

   326

                    def fn(event):

   327

                        b.SetFont(s)

   328

                        b.Refresh()

   329

                        event.Skip()

   330

                    return fn

   331

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

   332

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

   333

                # hack to force size to mini

   334

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

   335

                    button.Disable()

   336

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

   337

        return msizer

   338

   339

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

   340

        if clean:

   341

            sizer.Clear(True)

   342

        first = True

   343

        for element_infos in elements:

   344

            if path:

   345

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

   346

            else:

   347

                element_path = element_infos["name"]

   348

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

   349

                name = element_infos["name"]

   350

                value = element_infos["value"]

   351

                label = _(name)

   352

                if value is not None:

   353

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

   354

                staticbox = wx.StaticBox(self.ParamsEditor,

   355

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

   356

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

   357

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

   358

                if first:

   359

                    flags |= wx.TOP

   360

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

   361

                self.GenerateSizerElements(staticboxsizer,

   362

                                           element_infos["children"],

   363

                                           element_path)

   364

            else:

   365

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

   366

                boxsizer.AddGrowableCol(1)

   367

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

   368

                if first:

   369

                    flags |= wx.TOP

   370

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

   371

                staticbitmap = GenStaticBitmap(

   372

                    ID=-1, bitmapname=element_infos["name"],

   373

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

   374

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

   375

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

   376

   377

                statictext = wx.StaticText(self.ParamsEditor,

   378

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

   379

                boxsizer.AddWindow(statictext, border=5,

   380

                                   flag=wx.ALIGN_CENTER_VERTICAL | wx.RIGHT)

   381

   382

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

   383

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

   384

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   385

                        boxsizer.AddSizer(browse_boxsizer)

   386

   387

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   388

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

   389

                        if element_infos["value"] is not None:

   390

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

   391

                            value_infos = element_infos["value"][1]

   392

                        else:

   393

                            value_infos = None

   394

                        browse_boxsizer.AddWindow(textctrl)

   395

   396

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

   397

                        browse_boxsizer.AddWindow(button)

   398

                        button.Bind(wx.EVT_BUTTON,

   399

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

   400

                                                                   value_infos, element_path),

   401

                                    button)

   402

                    else:

   403

                        combobox = wx.ComboBox(self.ParamsEditor,

   404

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

   405

                        boxsizer.AddWindow(combobox)

   406

   407

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

   408

                            combobox.Append("")

   409

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

   410

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

   411

                                combobox.Append(choice)

   412

                            name = element_infos["name"]

   413

                            value = element_infos["value"]

   414

   415

                            staticbox = wx.StaticBox(self.ParamsEditor,

   416

                                                     label="%s - %s" % (_(name), _(value)),

   417

                                                     size=wx.Size(10, 0))

   418

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

   419

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

   420

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

   421

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

   422

                        else:

   423

                            for choice in element_infos["type"]:

   424

                                combobox.Append(choice)

   425

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   426

                        if element_infos["value"] is None:

   427

                            combobox.SetStringSelection("")

   428

                        else:

   429

                            combobox.SetStringSelection(element_infos["value"])

   430

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

   431

   432

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

   433

                    scmin = -(2**31)

   434

                    scmax = 2**31-1

   435

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

   436

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

   437

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

   438

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

   439

                    spinctrl = wx.SpinCtrl(self.ParamsEditor,

   440

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

   441

                                           style=wx.SP_ARROW_KEYS | wx.ALIGN_RIGHT)

   442

                    spinctrl.SetRange(scmin, scmax)

   443

                    boxsizer.AddWindow(spinctrl)

   444

                    if element_infos["value"] is not None:

   445

                        spinctrl.SetValue(element_infos["value"])

   446

                    spinctrl.Bind(wx.EVT_SPINCTRL,

   447

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   448

                                  spinctrl)

   449

   450

                else:

   451

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

   452

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

   453

                        boxsizer.AddWindow(checkbox)

   454

                        if element_infos["value"] is not None:

   455

                            checkbox.SetValue(element_infos["value"])

   456

                        checkbox.Bind(wx.EVT_CHECKBOX,

   457

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path),

   458

                                      checkbox)

   459

   460

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

   461

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

   462

                            scmin = 0

   463

                        else:

   464

                            scmin = -(2**31)

   465

                        scmax = 2**31-1

   466

                        spinctrl = wx.SpinCtrl(self.ParamsEditor,

   467

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

   468

                                               style=wx.SP_ARROW_KEYS | wx.ALIGN_RIGHT)

   469

                        spinctrl.SetRange(scmin, scmax)

   470

                        boxsizer.AddWindow(spinctrl)

   471

                        if element_infos["value"] is not None:

   472

                            spinctrl.SetValue(element_infos["value"])

   473

                        spinctrl.Bind(wx.EVT_SPINCTRL,

   474

                                      self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   475

                                      spinctrl)

   476

   477

                    else:

   478

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

   479

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

   480

                                                        parent=self.ParamsEditor,

   481

                                                        choices=choices,

   482

                                                        element_path=element_path,

   483

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

   484

   485

                        boxsizer.AddWindow(textctrl)

   486

                        if element_infos["value"] is not None:

   487

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

   488

                        callback = self.GetTextCtrlCallBackFunction(textctrl, element_path)

   489

                        textctrl.Bind(wx.EVT_TEXT_ENTER, callback)

   490

                        textctrl.Bind(wx.EVT_KILL_FOCUS, callback)

   491

            first = False