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(

   165

                    self.Editor,

   166

                    bitmap=GetBitmap('IECCDown'),

   167

                    size=wx.Size(16, 16),

   168

                    style=wx.NO_BORDER)

   169

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

   170

                                       self.IECCUpButton)

   171

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

   172

   173

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

   174

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

   175

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

   176

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

   177

                                         self.IECCDownButton)

   178

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

   179

   180

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

   181

                                                size=wx.Size(150, 25))

   182

                self.ConfNodeName.SetFont(

   183

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

   184

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

   185

                self.ConfNodeName.Bind(

   186

                    wx.EVT_TEXT,

   187

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

   188

                    self.ConfNodeName)

   189

                baseparamseditor_sizer.AddWindow(

   190

                    self.ConfNodeName, border=5,

   191

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

   192

   193

                buttons_sizer = self.GenerateMethodButtonSizer()

   194

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

   195

   196

            if tabs_num > 1:

   197

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

   198

                parent = self.ConfNodeNoteBook

   199

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

   200

            else:

   201

                parent = self.Editor

   202

                self.ConfNodeNoteBook = None

   203

   204

            self.Editor.SetSizer(self.MainSizer)

   205

        else:

   206

            self.ConfNodeNoteBook = None

   207

            self.Editor = None

   208

   209

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   210

            editor = getattr(self, create_func_name)(parent)

   211

            if self.ConfNodeNoteBook is not None:

   212

                self.ConfNodeNoteBook.AddPage(editor, title)

   213

            elif self.SHOW_BASE_PARAMS:

   214

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

   215

            else:

   216

                self.Editor = editor

   217

   218

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

   219

   220

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

   221

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

   222

                panel_style |= wx.SUNKEN_BORDER

   223

            self.ParamsEditor = wx.ScrolledWindow(parent,

   224

                                                  style=panel_style)

   225

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

   226

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

   227

   228

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

   229

            self.ParamsEditorSizer.AddGrowableCol(0)

   230

            self.ParamsEditorSizer.AddGrowableRow(0)

   231

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   232

   233

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

   234

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

   235

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

   236

   237

            self.RefreshConfNodeParamsSizer()

   238

   239

            if self.ConfNodeNoteBook is not None:

   240

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

   241

            elif self.SHOW_BASE_PARAMS:

   242

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

   243

            else:

   244

                self.Editor = self.ParamsEditor

   245

        else:

   246

            self.ParamsEditor = None

   247

   248

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

   249

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

   250

   251

        icon_name = self.Controler.GetIconName()

   252

        if icon_name is not None:

   253

            self.SetIcon(GetBitmap(icon_name))

   254

        else:

   255

            self.SetIcon(GetBitmap("Extension"))

   256

   257

    def __del__(self):

   258

        self.Controler.OnCloseEditor(self)

   259

   260

    def GetTagName(self):

   261

        return self.Controler.CTNFullName()

   262

   263

    def GetTitle(self):

   264

        fullname = self.Controler.CTNFullName()

   265

        if self.Controler.CTNTestModified():

   266

            return "~%s~" % fullname

   267

        return fullname

   268

   269

    def HasNoModel(self):

   270

        return False

   271

   272

    def GetBufferState(self):

   273

        return False, False

   274

   275

    def Undo(self):

   276

        pass

   277

   278

    def Redo(self):

   279

        pass

   280

   281

    def RefreshView(self):

   282

        EditorPanel.RefreshView(self)

   283

        if self.SHOW_BASE_PARAMS:

   284

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

   285

            self.RefreshIECChannelControlsState()

   286

        if self.ParamsEditor is not None:

   287

            self.RefreshConfNodeParamsSizer()

   288

            self.RefreshScrollbars()

   289

   290

    def RefreshIECChannelControlsState(self):

   291

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

   292

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

   293

        self.MainSizer.Layout()

   294

   295

    def RefreshConfNodeParamsSizer(self):

   296

        self.Freeze()

   297

        self.ConfNodeParamsSizer.Clear(True)

   298

   299

        confnode_infos = self.Controler.GetParamsAttributes()

   300

        if len(confnode_infos) > 0:

   301

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

   302

   303

        self.ParamsEditorSizer.Layout()

   304

        self.Thaw()

   305

   306

    def GenerateMethodButtonSizer(self):

   307

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

   308

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

   309

   310

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   311

   312

        for confnode_method in self.Controler.ConfNodeMethods:

   313

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

   314

                button = GenBitmapTextButton(self.Editor,

   315

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

   316

                                             label=confnode_method["name"],

   317

                                             style=wx.NO_BORDER)

   318

                button.SetFont(normal_bt_font)

   319

                button.SetToolTipString(confnode_method["tooltip"])

   320

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

   321

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

   322

                else:

   323

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

   324

                # a fancy underline on mouseover

   325

   326

                def setFontStyle(b, s):

   327

                    def fn(event):

   328

                        b.SetFont(s)

   329

                        b.Refresh()

   330

                        event.Skip()

   331

                    return fn

   332

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

   333

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

   334

                # hack to force size to mini

   335

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

   336

                    button.Disable()

   337

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

   338

        return msizer

   339

   340

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

   341

        if clean:

   342

            sizer.Clear(True)

   343

        first = True

   344

        for element_infos in elements:

   345

            if path:

   346

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

   347

            else:

   348

                element_path = element_infos["name"]

   349

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

   350

                name = element_infos["name"]

   351

                value = element_infos["value"]

   352

                label = _(name)

   353

                if value is not None:

   354

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

   355

                staticbox = wx.StaticBox(self.ParamsEditor,

   356

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

   357

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

   358

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

   359

                if first:

   360

                    flags |= wx.TOP

   361

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

   362

                self.GenerateSizerElements(staticboxsizer,

   363

                                           element_infos["children"],

   364

                                           element_path)

   365

            else:

   366

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

   367

                boxsizer.AddGrowableCol(1)

   368

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

   369

                if first:

   370

                    flags |= wx.TOP

   371

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

   372

                staticbitmap = GenStaticBitmap(

   373

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

   374

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

   375

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

   376

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

   377

   378

                statictext = wx.StaticText(self.ParamsEditor,

   379

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

   380

                boxsizer.AddWindow(statictext, border=5,

   381

                                   flag=wx.ALIGN_CENTER_VERTICAL | wx.RIGHT)

   382

   383

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

   384

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

   385

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   386

                        boxsizer.AddSizer(browse_boxsizer)

   387

   388

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   389

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

   390

                        if element_infos["value"] is not None:

   391

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

   392

                            value_infos = element_infos["value"][1]

   393

                        else:

   394

                            value_infos = None

   395

                        browse_boxsizer.AddWindow(textctrl)

   396

   397

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

   398

                        browse_boxsizer.AddWindow(button)

   399

                        button.Bind(wx.EVT_BUTTON,

   400

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

   401

                                                                   value_infos, element_path),

   402

                                    button)

   403

                    else:

   404

                        combobox = wx.ComboBox(self.ParamsEditor,

   405

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

   406

                        boxsizer.AddWindow(combobox)

   407

   408

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

   409

                            combobox.Append("")

   410

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

   411

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

   412

                                combobox.Append(choice)

   413

                            name = element_infos["name"]

   414

                            value = element_infos["value"]

   415

   416

                            staticbox = wx.StaticBox(self.ParamsEditor,

   417

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

   418

                                                     size=wx.Size(10, 0))

   419

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

   420

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

   421

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

   422

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

   423

                        else:

   424

                            for choice in element_infos["type"]:

   425

                                combobox.Append(choice)

   426

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   427

                        if element_infos["value"] is None:

   428

                            combobox.SetStringSelection("")

   429

                        else:

   430

                            combobox.SetStringSelection(element_infos["value"])

   431

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

   432

   433

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

   434

                    scmin = -(2**31)

   435

                    scmax = 2**31-1

   436

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

   437

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

   438

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

   439

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

   440

                    spinctrl = wx.SpinCtrl(self.ParamsEditor,

   441

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

   442

                                           style=wx.SP_ARROW_KEYS | wx.ALIGN_RIGHT)

   443

                    spinctrl.SetRange(scmin, scmax)

   444

                    boxsizer.AddWindow(spinctrl)

   445

                    if element_infos["value"] is not None:

   446

                        spinctrl.SetValue(element_infos["value"])

   447

                    spinctrl.Bind(wx.EVT_SPINCTRL,

   448

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   449

                                  spinctrl)

   450

   451

                else:

   452

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

   453

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

   454

                        boxsizer.AddWindow(checkbox)

   455

                        if element_infos["value"] is not None:

   456

                            checkbox.SetValue(element_infos["value"])

   457

                        checkbox.Bind(wx.EVT_CHECKBOX,

   458

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path),

   459

                                      checkbox)

   460

   461

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

   462

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

   463

                            scmin = 0

   464

                        else:

   465

                            scmin = -(2**31)

   466

                        scmax = 2**31-1

   467

                        spinctrl = wx.SpinCtrl(self.ParamsEditor,

   468

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

   469

                                               style=wx.SP_ARROW_KEYS | wx.ALIGN_RIGHT)

   470

                        spinctrl.SetRange(scmin, scmax)

   471

                        boxsizer.AddWindow(spinctrl)

   472

                        if element_infos["value"] is not None:

   473

                            spinctrl.SetValue(element_infos["value"])

   474

                        spinctrl.Bind(wx.EVT_SPINCTRL,

   475

                                      self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   476

                                      spinctrl)

   477

   478

                    else:

   479

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

   480

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

   481

                                                        parent=self.ParamsEditor,

   482

                                                        choices=choices,

   483

                                                        element_path=element_path,

   484

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

   485

   486

                        boxsizer.AddWindow(textctrl)

   487

                        if element_infos["value"] is not None:

   488

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

   489

                        callback = self.GetTextCtrlCallBackFunction(textctrl, element_path)

   490

                        textctrl.Bind(wx.EVT_TEXT_ENTER, callback)

   491

                        textctrl.Bind(wx.EVT_KILL_FOCUS, callback)