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

    27

    28

    29

    30

import wx

    31

    32

from editors.EditorPanel import EditorPanel

    33

    34

from IDEFrame import TITLE, FILEMENU, PROJECTTREE, PAGETITLES

    35

    36

from controls import TextCtrlAutoComplete

    37

from dialogs import BrowseValuesLibraryDialog, UriEditor

    38

from util.BitmapLibrary import GetBitmap

    39

    40

if wx.Platform == '__WXMSW__':

    41

    faces = {

    42

        'times': 'Times New Roman',

    43

        'mono':  'Courier New',

    44

        'helv':  'Arial',

    45

        'other': 'Comic Sans MS',

    46

        'size':  16,

    47

    }

    48

else:

    49

    faces = {

    50

        'times': 'Times',

    51

        'mono':  'FreeMono',

    52

        'helv':  'Helvetica',

    53

        'other': 'new century schoolbook',

    54

        'size':  18,

    55

    }

    56

    57

SCROLLBAR_UNIT = 10

    58

    59

    60

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

    61

    def _GetLabelSize(self):

    62

        """ used internally """

    63

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

    64

        if not self.bmpLabel:

    65

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

    66

    67

        w_bmp = self.bmpLabel.GetWidth()+2

    68

        h_bmp = self.bmpLabel.GetHeight()+2

    69

        height = h + h_bmp

    70

        if w_bmp > w:

    71

            width = w_bmp

    72

        else:

    73

            width = w

    74

        return width, height, False

    75

    76

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

    77

        bmp = self.bmpLabel

    78

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

    79

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

    80

                bmp = self.bmpDisabled

    81

            if self.bmpFocus and self.hasFocus:

    82

                bmp = self.bmpFocus

    83

            if self.bmpSelected and not self.up:

    84

                bmp = self.bmpSelected

    85

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

    86

            if not self.up:

    87

                dw = dy = self.labelDelta

    88

            hasMask = bmp.GetMask() is not None

    89

        else:

    90

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

    91

    92

        dc.SetFont(self.GetFont())

    93

        if self.IsEnabled():

    94

            dc.SetTextForeground(self.GetForegroundColour())

    95

        else:

    96

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

    97

    98

        label = self.GetLabel()

    99

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

   100

        if not self.up:

   101

            dw = dy = self.labelDelta

   102

   103

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

   104

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

   105

        if bmp is not None:

   106

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

   107

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

   108

            pos_y += bh + 2

   109

   110

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

   111

   112

   113

class GenStaticBitmap(wx.StaticBitmap):

   114

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

   115

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

   116

    def __init__(self, parent, ID, bitmapname,

   117

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

   118

                 style=0,

   119

                 name="genstatbmp"):

   120

   121

        bitmap = GetBitmap(bitmapname)

   122

        if bitmap is None:

   123

            bitmap = wx.Bitmap()

   124

   125

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

   126

                                 bitmap,

   127

                                 pos, size,

   128

                                 style,

   129

                                 name)

   130

   131

   132

class ConfTreeNodeEditor(EditorPanel):

   133

   134

    SHOW_BASE_PARAMS = True

   135

    SHOW_PARAMS = True

   136

    CONFNODEEDITOR_TABS = []

   137

   138

    def _init_Editor(self, parent):

   139

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   140

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

   141

            tabs_num += 1

   142

   143

        if tabs_num > 1 or self.SHOW_BASE_PARAMS:

   144

            self.Editor = wx.Panel(parent,

   145

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   146

   147

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

   148

   149

            if self.SHOW_BASE_PARAMS:

   150

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   151

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

   152

                                        flag=wx.GROW | wx.ALL)

   153

   154

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

   155

                self.FullIECChannel.SetFont(

   156

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

   157

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

   158

                baseparamseditor_sizer.Add(self.FullIECChannel,

   159

                                                 flag=wx.ALIGN_CENTER_VERTICAL)

   160

   161

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   162

                baseparamseditor_sizer.Add(updownsizer, border=5,

   163

                                                flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL)

   164

   165

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

   166

                    self.Editor,

   167

                    bitmap=GetBitmap('IECCDown'),

   168

                    size=wx.Size(16, 16),

   169

                    style=wx.NO_BORDER)

   170

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

   171

                                       self.IECCUpButton)

   172

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

   173

   174

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

   175

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

   176

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

   177

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

   178

                                         self.IECCDownButton)

   179

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

   180

   181

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

   182

                                                size=wx.Size(150, 25))

   183

                self.ConfNodeName.SetFont(

   184

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

   185

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

   186

                self.ConfNodeName.Bind(

   187

                    wx.EVT_TEXT,

   188

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

   189

                    self.ConfNodeName)

   190

                baseparamseditor_sizer.Add(

   191

                    self.ConfNodeName, border=5,

   192

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

   193

   194

                buttons_sizer = self.GenerateMethodButtonSizer()

   195

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

   196

   197

            if tabs_num > 1:

   198

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

   199

                parent = self.ConfNodeNoteBook

   200

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

   201

            else:

   202

                parent = self.Editor

   203

                self.ConfNodeNoteBook = None

   204

   205

            self.Editor.SetSizer(self.MainSizer)

   206

        else:

   207

            self.ConfNodeNoteBook = None

   208

            self.Editor = None

   209

   210

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   211

            editor = getattr(self, create_func_name)(parent)

   212

            if self.ConfNodeNoteBook is not None:

   213

                self.ConfNodeNoteBook.AddPage(editor, title)

   214

            elif self.SHOW_BASE_PARAMS:

   215

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

   216

            else:

   217

                self.Editor = editor

   218

   219

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

   220

   221

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

   222

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

   223

                panel_style |= wx.SUNKEN_BORDER

   224

            self.ParamsEditor = wx.ScrolledWindow(parent,

   225

                                                  style=panel_style)

   226

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

   227

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

   228

   229

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

   230

            self.ParamsEditorSizer.AddGrowableCol(0)

   231

            self.ParamsEditorSizer.AddGrowableRow(0)

   232

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   233

   234

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

   235

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

   236

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

   237

   238

            self.RefreshConfNodeParamsSizer()

   239

   240

            if self.ConfNodeNoteBook is not None:

   241

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

   242

            elif self.SHOW_BASE_PARAMS:

   243

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

   244

            else:

   245

                self.Editor = self.ParamsEditor

   246

        else:

   247

            self.ParamsEditor = None

   248

   249

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

   250

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

   251

   252

        icon_name = self.Controler.GetIconName()

   253

        if icon_name is not None:

   254

            self.SetIcon(GetBitmap(icon_name))

   255

        else:

   256

            self.SetIcon(GetBitmap("Extension"))

   257

   258

    def GetTagName(self):

   259

        return self.Controler.CTNFullName()

   260

   261

    def GetTitle(self):

   262

        fullname = self.Controler.CTNFullName()

   263

        if self.Controler.CTNTestModified():

   264

            return "~%s~" % fullname

   265

        return fullname

   266

   267

    def HasNoModel(self):

   268

        return False

   269

   270

    def GetBufferState(self):

   271

        return False, False

   272

   273

    def Undo(self):

   274

        pass

   275

   276

    def Redo(self):

   277

        pass

   278

   279

    def RefreshView(self):

   280

        EditorPanel.RefreshView(self)

   281

        if self.SHOW_BASE_PARAMS:

   282

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

   283

            self.RefreshIECChannelControlsState()

   284

        if self.ParamsEditor is not None:

   285

            self.RefreshConfNodeParamsSizer()

   286

            self.RefreshScrollbars()

   287

   288

    def RefreshIECChannelControlsState(self):

   289

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

   290

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

   291

        self.MainSizer.Layout()

   292

   293

    def RefreshConfNodeParamsSizer(self):

   294

        self.Freeze()

   295

        self.ConfNodeParamsSizer.Clear(True)

   296

   297

        confnode_infos = self.Controler.GetParamsAttributes()

   298

        if len(confnode_infos) > 0:

   299

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

   300

   301

        self.ParamsEditorSizer.Layout()

   302

        self.Thaw()

   303

   304

    def GenerateMethodButtonSizer(self):

   305

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

   306

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

   307

   308

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   309

   310

        for confnode_method in self.Controler.ConfNodeMethods:

   311

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

   312

                button = GenBitmapTextButton(self.Editor,

   313

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

   314

                                             label=confnode_method["name"],

   315

                                             style=wx.NO_BORDER)

   316

                button.SetFont(normal_bt_font)

   317

                button.SetToolTip(confnode_method["tooltip"])

   318

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

   319

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

   320

                else:

   321

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

   322

                # a fancy underline on mouseover

   323

   324

                def setFontStyle(b, s):

   325

                    def fn(event):

   326

                        b.SetFont(s)

   327

                        b.Refresh()

   328

                        event.Skip()

   329

                    return fn

   330

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

   331

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

   332

                # hack to force size to mini

   333

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

   334

                    button.Disable()

   335

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

   336

        return msizer

   337

   338

    def UriOptions(self, event):

   339

        CTR = self.ParentWindow.CTR

   340

        CTR_BeremizRoot = CTR.BeremizRoot

   341

        CTR_AppFrame = CTR.AppFrame

   342

   343

        # Get connector uri

   344

        uri = CTR_BeremizRoot.getURI_location().strip()

   345

        dialog = UriEditor(CTR_AppFrame, CTR, uri)

   346

   347

        if dialog.ShowModal() == wx.ID_OK:

   348

            CTR_BeremizRoot.setURI_location(dialog.GetURI())

   349

            if CTR._View is not None:

   350

                CTR._View.RefreshView()

   351

            if CTR_AppFrame is not None:

   352

                CTR_AppFrame.RefreshTitle()

   353

                CTR_AppFrame.RefreshFileMenu()

   354

                CTR_AppFrame.RefreshEditMenu()

   355

                CTR_AppFrame.RefreshPageTitles()

   356

   357

        dialog.Destroy()

   358

   359

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

   360

        if clean:

   361

            sizer.Clear(True)

   362

        first = True

   363

        for element_infos in elements:

   364

            if path:

   365

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

   366

            else:

   367

                element_path = element_infos["name"]

   368

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

   369

                name = element_infos["name"]

   370

                value = element_infos["value"]

   371

                label = _(name)

   372

                if value is not None:

   373

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

   374

                staticbox = wx.StaticBox(self.ParamsEditor,

   375

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

   376

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

   377

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

   378

                if first:

   379

                    flags |= wx.TOP

   380

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

   381

                self.GenerateSizerElements(staticboxsizer,

   382

                                           element_infos["children"],

   383

                                           element_path)

   384

            else:

   385

                boxsizer = wx.FlexGridSizer(cols=4, rows=1, gap=wx.Size(0,0))

   386

                boxsizer.AddGrowableCol(1)

   387

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

   388

                if first:

   389

                    flags |= wx.TOP

   390

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

   391

                staticbitmap = GenStaticBitmap(

   392

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

   393

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

   394

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

   395

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

   396

   397

                label = element_infos["name"].replace('_', ' ')

   398

                statictext = wx.StaticText(self.ParamsEditor,

   399

                                           label="%s:" % _(label))

   400

                boxsizer.Add(statictext, border=5,

   401

                                   flag=wx.ALIGN_CENTER_VERTICAL | wx.RIGHT)

   402

   403

                if isinstance(element_infos["type"], list):

   404

                    if isinstance(element_infos["value"], tuple):

   405

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   406

                        boxsizer.Add(browse_boxsizer)

   407

   408

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   409

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

   410

                        if element_infos["value"] is not None:

   411

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

   412

                            value_infos = element_infos["value"][1]

   413

                        else:

   414

                            value_infos = None

   415

                        browse_boxsizer.Add(textctrl)

   416

   417

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

   418

                        browse_boxsizer.Add(button)

   419

                        button.Bind(wx.EVT_BUTTON,

   420

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

   421

                                                                   value_infos, element_path),

   422

                                    button)

   423

                    else:

   424

                        combobox = wx.ComboBox(self.ParamsEditor,

   425

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

   426

                        boxsizer.Add(combobox)

   427

   428

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

   429

                            combobox.Append("")

   430

                        if len(element_infos["type"]) > 0 and isinstance(element_infos["type"][0], tuple):

   431

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

   432

                                combobox.Append(choice.replace('_',' '))

   433

                            name = element_infos["name"]

   434

                            value = element_infos["value"]

   435

   436

                            staticboxsizer = None

   437

                            if element_infos["children"]:

   438

                                staticbox = wx.StaticBox(self.ParamsEditor,

   439

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

   440

                                                         size=wx.Size(10, 0))

   441

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

   442

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

   443

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

   444

   445

                            callback = self.GetChoiceContentCallBackFunction(combobox, element_path)

   446

                        else:

   447

                            for choice in element_infos["type"]:

   448

                                combobox.Append(choice)

   449

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   450

                        if element_infos["value"] is None:

   451

                            combobox.SetStringSelection("")

   452

                        else:

   453

                            combobox.SetStringSelection(

   454

                                element_infos["value"].replace('_',' '))

   455

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

   456

   457

                elif isinstance(element_infos["type"], dict):

   458

                    scmin = -(2**31)

   459

                    scmax = 2**31-1

   460

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

   461

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

   462

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

   463

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

   464

                    spinctrl = wx.SpinCtrl(self.ParamsEditor,

   465

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

   466

                                           style=wx.SP_ARROW_KEYS | wx.ALIGN_RIGHT)

   467

                    spinctrl.SetRange(scmin, scmax)

   468

                    boxsizer.Add(spinctrl)

   469

                    if element_infos["value"] is not None:

   470

                        spinctrl.SetValue(element_infos["value"])

   471

                    spinctrl.Bind(wx.EVT_SPINCTRL,

   472

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   473

                                  spinctrl)

   474

   475

                else:

   476

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

   477

                        checkbox = wx.CheckBox(self.ParamsEditor)

   478

                        boxsizer.Add(checkbox, flag=wx.ALIGN_CENTER_VERTICAL | wx.RIGHT)

   479

                        if element_infos["value"] is not None:

   480

                            checkbox.SetValue(element_infos["value"])

   481

                        checkbox.Bind(wx.EVT_CHECKBOX,

   482

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path),

   483

                                      checkbox)

   484

   485

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

   486

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

   487

                            scmin = 0

   488

                        else:

   489

                            scmin = -(2**31)