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

from __future__ import absolute_import

    28

from __future__ import division

    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(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 __del__(self):

   259

        self.Controler.OnCloseEditor(self)

   260

   261

    def GetTagName(self):

   262

        return self.Controler.CTNFullName()

   263

   264

    def GetTitle(self):

   265

        fullname = self.Controler.CTNFullName()

   266

        if self.Controler.CTNTestModified():

   267

            return "~%s~" % fullname

   268

        return fullname

   269

   270

    def HasNoModel(self):

   271

        return False

   272

   273

    def GetBufferState(self):

   274

        return False, False

   275

   276

    def Undo(self):

   277

        pass

   278

   279

    def Redo(self):

   280

        pass

   281

   282

    def RefreshView(self):

   283

        EditorPanel.RefreshView(self)

   284

        if self.SHOW_BASE_PARAMS:

   285

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

   286

            self.RefreshIECChannelControlsState()

   287

        if self.ParamsEditor is not None:

   288

            self.RefreshConfNodeParamsSizer()

   289

            self.RefreshScrollbars()

   290

   291

    def RefreshIECChannelControlsState(self):

   292

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

   293

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

   294

        self.MainSizer.Layout()

   295

   296

    def RefreshConfNodeParamsSizer(self):

   297

        self.Freeze()

   298

        self.ConfNodeParamsSizer.Clear(True)

   299

   300

        confnode_infos = self.Controler.GetParamsAttributes()

   301

        if len(confnode_infos) > 0:

   302

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

   303

   304

        self.ParamsEditorSizer.Layout()

   305

        self.Thaw()

   306

   307

    def GenerateMethodButtonSizer(self):

   308

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

   309

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

   310

   311

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   312

   313

        for confnode_method in self.Controler.ConfNodeMethods:

   314

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

   315

                button = GenBitmapTextButton(self.Editor,

   316

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

   317

                                             label=confnode_method["name"],

   318

                                             style=wx.NO_BORDER)

   319

                button.SetFont(normal_bt_font)

   320

                button.SetToolTip(confnode_method["tooltip"])

   321

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

   322

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

   323

                else:

   324

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

   325

                # a fancy underline on mouseover

   326

   327

                def setFontStyle(b, s):

   328

                    def fn(event):

   329

                        b.SetFont(s)

   330

                        b.Refresh()

   331

                        event.Skip()

   332

                    return fn

   333

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

   334

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

   335

                # hack to force size to mini

   336

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

   337

                    button.Disable()

   338

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

   339

        return msizer

   340

   341

    def UriOptions(self, event):

   342

        CTR = self.ParentWindow.CTR

   343

        CTR_BeremizRoot = CTR.BeremizRoot

   344

        CTR_AppFrame = CTR.AppFrame

   345

   346

        # Get connector uri

   347

        uri = CTR_BeremizRoot.getURI_location().strip()

   348

        dialog = UriEditor(CTR_AppFrame, CTR, uri)

   349

   350

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

   351

            CTR_BeremizRoot.setURI_location(dialog.GetURI())

   352

            if CTR._View is not None:

   353

                CTR._View.RefreshView()

   354

            if CTR_AppFrame is not None:

   355

                CTR_AppFrame.RefreshTitle()

   356

                CTR_AppFrame.RefreshFileMenu()

   357

                CTR_AppFrame.RefreshEditMenu()

   358

                CTR_AppFrame.RefreshPageTitles()

   359

   360

        dialog.Destroy()

   361

   362

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

   363

        if clean:

   364

            sizer.Clear(True)

   365

        first = True

   366

        for element_infos in elements:

   367

            if path:

   368

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

   369

            else:

   370

                element_path = element_infos["name"]

   371

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

   372

                name = element_infos["name"]

   373

                value = element_infos["value"]

   374

                label = _(name)

   375

                if value is not None:

   376

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

   377

                staticbox = wx.StaticBox(self.ParamsEditor,

   378

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

   379

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

   380

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

   381

                if first:

   382

                    flags |= wx.TOP

   383

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

   384

                self.GenerateSizerElements(staticboxsizer,

   385

                                           element_infos["children"],

   386

                                           element_path)

   387

            else:

   388

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

   389

                boxsizer.AddGrowableCol(1)

   390

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

   391

                if first:

   392

                    flags |= wx.TOP

   393

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

   394

                staticbitmap = GenStaticBitmap(

   395

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

   396

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

   397

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

   398

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

   399

   400

                statictext = wx.StaticText(self.ParamsEditor,

   401

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

   402

                boxsizer.Add(statictext, border=5,

   403

                                   flag=wx.ALIGN_CENTER_VERTICAL | wx.RIGHT)

   404

   405

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

   406

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

   407

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   408

                        boxsizer.Add(browse_boxsizer)

   409

   410

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   411

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

   412

                        if element_infos["value"] is not None:

   413

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

   414

                            value_infos = element_infos["value"][1]

   415

                        else:

   416

                            value_infos = None

   417

                        browse_boxsizer.Add(textctrl)

   418

   419

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

   420

                        browse_boxsizer.Add(button)

   421

                        button.Bind(wx.EVT_BUTTON,

   422

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

   423

                                                                   value_infos, element_path),

   424

                                    button)

   425

                    else:

   426

                        combobox = wx.ComboBox(self.ParamsEditor,

   427

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

   428

                        boxsizer.Add(combobox)

   429

   430

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

   431

                            combobox.Append("")

   432

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

   433

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

   434

                                combobox.Append(choice)

   435

                            name = element_infos["name"]

   436

                            value = element_infos["value"]

   437

   438

                            staticboxsizer = None

   439

                            if element_infos["children"]:

   440

                                staticbox = wx.StaticBox(self.ParamsEditor,

   441

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

   442

                                                         size=wx.Size(10, 0))

   443

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

   444

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

   445

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

   446

   447

                            callback = self.GetChoiceContentCallBackFunction(combobox, element_path)

   448

                        else:

   449

                            for choice in element_infos["type"]:

   450

                                combobox.Append(choice)

   451

                            callback = self.GetChoiceCallBackFunction(combobox, element_path)

   452

                        if element_infos["value"] is None:

   453

                            combobox.SetStringSelection("")

   454

                        else:

   455

                            combobox.SetStringSelection(element_infos["value"])

   456

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

   457

   458

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

   459

                    scmin = -(2**31)

   460

                    scmax = 2**31-1

   461

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

   462

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

   463

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

   464

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

   465

                    spinctrl = wx.SpinCtrl(self.ParamsEditor,

   466

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

   467

                                           style=wx.SP_ARROW_KEYS | wx.ALIGN_RIGHT)

   468

                    spinctrl.SetRange(scmin, scmax)

   469

                    boxsizer.Add(spinctrl)

   470

                    if element_infos["value"] is not None:

   471

                        spinctrl.SetValue(element_infos["value"])

   472

                    spinctrl.Bind(wx.EVT_SPINCTRL,

   473

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   474

                                  spinctrl)

   475

   476

                else:

   477

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

   478

                        checkbox = wx.CheckBox(self.ParamsEditor)

   479

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

   480

                        if element_infos["value"] is not None:

   481

                            checkbox.SetValue(element_infos["value"])

   482

                        checkbox.Bind(wx.EVT_CHECKBOX,

   483

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path),

   484

                                      checkbox)

   485

   486

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

   487

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

   488

                            scmin = 0

   489

                        else: