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

import types

    30

    31

import wx

    32

    33

from editors.EditorPanel import EditorPanel

    34

    35

from IDEFrame import TITLE, FILEMENU, PROJECTTREE, PAGETITLES

    36

    37

from controls import TextCtrlAutoComplete, UriLocationEditor

    38

from dialogs import BrowseValuesLibraryDialog

    39

from util.BitmapLibrary import GetBitmap

    40

    41

if wx.Platform == '__WXMSW__':

    42

    faces = {

    43

        'times': 'Times New Roman',

    44

        'mono':  'Courier New',

    45

        'helv':  'Arial',

    46

        'other': 'Comic Sans MS',

    47

        'size':  16,

    48

    }

    49

else:

    50

    faces = {

    51

        'times': 'Times',

    52

        'mono':  'Courier',

    53

        'helv':  'Helvetica',

    54

        'other': 'new century schoolbook',

    55

        'size':  18,

    56

    }

    57

    58

SCROLLBAR_UNIT = 10

    59

    60

    61

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

    62

    def _GetLabelSize(self):

    63

        """ used internally """

    64

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

    65

        if not self.bmpLabel:

    66

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

    67

    68

        w_bmp = self.bmpLabel.GetWidth()+2

    69

        h_bmp = self.bmpLabel.GetHeight()+2

    70

        height = h + h_bmp

    71

        if w_bmp > w:

    72

            width = w_bmp

    73

        else:

    74

            width = w

    75

        return width, height, False

    76

    77

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

    78

        bmp = self.bmpLabel

    79

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

    80

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

    81

                bmp = self.bmpDisabled

    82

            if self.bmpFocus and self.hasFocus:

    83

                bmp = self.bmpFocus

    84

            if self.bmpSelected and not self.up:

    85

                bmp = self.bmpSelected

    86

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

    87

            if not self.up:

    88

                dw = dy = self.labelDelta

    89

            hasMask = bmp.GetMask() is not None

    90

        else:

    91

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

    92

    93

        dc.SetFont(self.GetFont())

    94

        if self.IsEnabled():

    95

            dc.SetTextForeground(self.GetForegroundColour())

    96

        else:

    97

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

    98

    99

        label = self.GetLabel()

   100

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

   101

        if not self.up:

   102

            dw = dy = self.labelDelta

   103

   104

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

   105

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

   106

        if bmp is not None:

   107

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

   108

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

   109

            pos_y += bh + 2

   110

   111

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

   112

   113

   114

class GenStaticBitmap(wx.StaticBitmap):

   115

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

   116

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

   117

    def __init__(self, parent, ID, bitmapname,

   118

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

   119

                 style=0,

   120

                 name="genstatbmp"):

   121

   122

        bitmap = GetBitmap(bitmapname)

   123

        if bitmap is None:

   124

            bitmap = wx.EmptyBitmap(0, 0)

   125

   126

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

   127

                                 bitmap,

   128

                                 pos, size,

   129

                                 style,

   130

                                 name)

   131

   132

   133

class ConfTreeNodeEditor(EditorPanel):

   134

   135

    SHOW_BASE_PARAMS = True

   136

    SHOW_PARAMS = True

   137

    CONFNODEEDITOR_TABS = []

   138

   139

    def _init_Editor(self, parent):

   140

        tabs_num = len(self.CONFNODEEDITOR_TABS)

   141

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

   142

            tabs_num += 1

   143

   144

        if tabs_num > 1 or self.SHOW_BASE_PARAMS:

   145

            self.Editor = wx.Panel(parent,

   146

                                   style=wx.SUNKEN_BORDER | wx.SP_3D)

   147

   148

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

   149

   150

            if self.SHOW_BASE_PARAMS:

   151

                baseparamseditor_sizer = wx.BoxSizer(wx.HORIZONTAL)

   152

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

   153

                                        flag=wx.GROW | wx.ALL)

   154

   155

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

   156

                self.FullIECChannel.SetFont(

   157

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

   158

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

   159

                baseparamseditor_sizer.AddWindow(self.FullIECChannel,

   160

                                                 flag=wx.ALIGN_CENTER_VERTICAL)

   161

   162

                updownsizer = wx.BoxSizer(wx.VERTICAL)

   163

                baseparamseditor_sizer.AddSizer(updownsizer, border=5,

   164

                                                flag=wx.LEFT | wx.ALIGN_CENTER_VERTICAL)

   165

   166

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

   167

                    self.Editor,

   168

                    bitmap=GetBitmap('IECCDown'),

   169

                    size=wx.Size(16, 16),

   170

                    style=wx.NO_BORDER)

   171

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

   172

                                       self.IECCUpButton)

   173

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

   174

   175

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

   176

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

   177

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

   178

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

   179

                                         self.IECCDownButton)

   180

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

   181

   182

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

   183

                                                size=wx.Size(150, 25))

   184

                self.ConfNodeName.SetFont(

   185

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

   186

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

   187

                self.ConfNodeName.Bind(

   188

                    wx.EVT_TEXT,

   189

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

   190

                    self.ConfNodeName)

   191

                baseparamseditor_sizer.AddWindow(

   192

                    self.ConfNodeName, border=5,

   193

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

   194

   195

                buttons_sizer = self.GenerateMethodButtonSizer()

   196

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

   197

   198

            if tabs_num > 1:

   199

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

   200

                parent = self.ConfNodeNoteBook

   201

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

   202

            else:

   203

                parent = self.Editor

   204

                self.ConfNodeNoteBook = None

   205

   206

            self.Editor.SetSizer(self.MainSizer)

   207

        else:

   208

            self.ConfNodeNoteBook = None

   209

            self.Editor = None

   210

   211

        for title, create_func_name in self.CONFNODEEDITOR_TABS:

   212

            editor = getattr(self, create_func_name)(parent)

   213

            if self.ConfNodeNoteBook is not None:

   214

                self.ConfNodeNoteBook.AddPage(editor, title)

   215

            elif self.SHOW_BASE_PARAMS:

   216

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

   217

            else:

   218

                self.Editor = editor

   219

   220

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

   221

   222

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

   223

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

   224

                panel_style |= wx.SUNKEN_BORDER

   225

            self.ParamsEditor = wx.ScrolledWindow(parent,

   226

                                                  style=panel_style)

   227

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

   228

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

   229

   230

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

   231

            self.ParamsEditorSizer.AddGrowableCol(0)

   232

            self.ParamsEditorSizer.AddGrowableRow(0)

   233

            self.ParamsEditor.SetSizer(self.ParamsEditorSizer)

   234

   235

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

   236

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

   237

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

   238

   239

            self.RefreshConfNodeParamsSizer()

   240

   241

            if self.ConfNodeNoteBook is not None:

   242

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

   243

            elif self.SHOW_BASE_PARAMS:

   244

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

   245

            else:

   246

                self.Editor = self.ParamsEditor

   247

        else:

   248

            self.ParamsEditor = None

   249

   250

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

   251

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

   252

   253

        icon_name = self.Controler.GetIconName()

   254

        if icon_name is not None:

   255

            self.SetIcon(GetBitmap(icon_name))

   256

        else:

   257

            self.SetIcon(GetBitmap("Extension"))

   258

   259

    def __del__(self):

   260

        self.Controler.OnCloseEditor(self)

   261

   262

    def GetTagName(self):

   263

        return self.Controler.CTNFullName()

   264

   265

    def GetTitle(self):

   266

        fullname = self.Controler.CTNFullName()

   267

        if self.Controler.CTNTestModified():

   268

            return "~%s~" % fullname

   269

        return fullname

   270

   271

    def HasNoModel(self):

   272

        return False

   273

   274

    def GetBufferState(self):

   275

        return False, False

   276

   277

    def Undo(self):

   278

        pass

   279

   280

    def Redo(self):

   281

        pass

   282

   283

    def RefreshView(self):

   284

        EditorPanel.RefreshView(self)

   285

        if self.SHOW_BASE_PARAMS:

   286

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

   287

            self.RefreshIECChannelControlsState()

   288

        if self.ParamsEditor is not None:

   289

            self.RefreshConfNodeParamsSizer()

   290

            self.RefreshScrollbars()

   291

   292

    def RefreshIECChannelControlsState(self):

   293

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

   294

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

   295

        self.MainSizer.Layout()

   296

   297

    def RefreshConfNodeParamsSizer(self):

   298

        self.Freeze()

   299

        self.ConfNodeParamsSizer.Clear(True)

   300

   301

        confnode_infos = self.Controler.GetParamsAttributes()

   302

        if len(confnode_infos) > 0:

   303

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

   304

   305

        self.ParamsEditorSizer.Layout()

   306

        self.Thaw()

   307

   308

    def GenerateMethodButtonSizer(self):

   309

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

   310

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

   311

   312

        msizer = wx.BoxSizer(wx.HORIZONTAL)

   313

   314

        for confnode_method in self.Controler.ConfNodeMethods:

   315

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

   316

                button = GenBitmapTextButton(self.Editor,

   317

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

   318

                                             label=confnode_method["name"],

   319

                                             style=wx.NO_BORDER)

   320

                button.SetFont(normal_bt_font)

   321

                button.SetToolTipString(confnode_method["tooltip"])

   322

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

   323

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

   324

                else:

   325

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

   326

                # a fancy underline on mouseover

   327

   328

                def setFontStyle(b, s):

   329

                    def fn(event):

   330

                        b.SetFont(s)

   331

                        b.Refresh()

   332

                        event.Skip()

   333

                    return fn

   334

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

   335

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

   336

                # hack to force size to mini

   337

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

   338

                    button.Disable()

   339

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

   340

        return msizer

   341

   342

    def UriOptions(self, event):

   343

        CTR = self.ParentWindow.CTR

   344

        CTR_BeremizRoot = CTR.BeremizRoot

   345

        CTR_AppFrame = CTR.AppFrame

   346

   347

        # Get connector uri

   348

        uri = CTR_BeremizRoot.getURI_location().strip()

   349

        dialog = UriLocationEditor.UriLocationEditor(CTR_AppFrame, uri)

   350

   351

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

   352

            CTR_BeremizRoot.setURI_location(dialog.GetURI())

   353

            if CTR._View is not None:

   354

                CTR._View.RefreshView()

   355

            if CTR_AppFrame is not None:

   356

                CTR_AppFrame.RefreshTitle()

   357

                CTR_AppFrame.RefreshFileMenu()

   358

                CTR_AppFrame.RefreshEditMenu()

   359

                CTR_AppFrame.RefreshPageTitles()

   360

   361

        dialog.Destroy()

   362

   363

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

   364

        if clean:

   365

            sizer.Clear(True)

   366

        first = True

   367

        for element_infos in elements:

   368

            if path:

   369

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

   370

            else:

   371

                element_path = element_infos["name"]

   372

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

   373

                name = element_infos["name"]

   374

                value = element_infos["value"]

   375

                label = _(name)

   376

                if value is not None:

   377

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

   378

                staticbox = wx.StaticBox(self.ParamsEditor,

   379

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

   380

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

   381

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

   382

                if first:

   383

                    flags |= wx.TOP

   384

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

   385

                self.GenerateSizerElements(staticboxsizer,

   386

                                           element_infos["children"],

   387

                                           element_path)

   388

            else:

   389

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

   390

                boxsizer.AddGrowableCol(1)

   391

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

   392

                if first:

   393

                    flags |= wx.TOP

   394

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

   395

                staticbitmap = GenStaticBitmap(

   396

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

   397

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

   398

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

   399

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

   400

   401

                statictext = wx.StaticText(self.ParamsEditor,

   402

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

   403

                boxsizer.AddWindow(statictext, border=5,

   404

                                   flag=wx.ALIGN_CENTER_VERTICAL | wx.RIGHT)

   405

   406

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

   407

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

   408

                        browse_boxsizer = wx.BoxSizer(wx.HORIZONTAL)

   409

                        boxsizer.AddSizer(browse_boxsizer)

   410

   411

                        textctrl = wx.TextCtrl(self.ParamsEditor,

   412

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

   413

                        if element_infos["value"] is not None:

   414

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

   415

                            value_infos = element_infos["value"][1]

   416

                        else:

   417

                            value_infos = None

   418

                        browse_boxsizer.AddWindow(textctrl)

   419

   420

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

   421

                        browse_boxsizer.AddWindow(button)

   422

                        button.Bind(wx.EVT_BUTTON,

   423

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

   424

                                                                   value_infos, element_path),

   425

                                    button)

   426

                    else:

   427

                        combobox = wx.ComboBox(self.ParamsEditor,

   428

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

   429

                        boxsizer.AddWindow(combobox)

   430

   431

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

   432

                            combobox.Append("")

   433

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

   434

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

   435

                                combobox.Append(choice)

   436

                            name = element_infos["name"]

   437

                            value = element_infos["value"]

   438

   439

                            staticbox = wx.StaticBox(self.ParamsEditor,

   440

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

   441

                                                     size=wx.Size(10, 0))

   442

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

   443

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

   444

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

   445

                            callback = self.GetChoiceContentCallBackFunction(combobox, staticboxsizer, 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(element_infos["value"])

   454

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

   455

   456

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

   457

                    scmin = -(2**31)

   458

                    scmax = 2**31-1

   459

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

   460

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

   461

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

   462

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

   463

                    spinctrl = wx.SpinCtrl(self.ParamsEditor,

   464

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

   465

                                           style=wx.SP_ARROW_KEYS | wx.ALIGN_RIGHT)

   466

                    spinctrl.SetRange(scmin, scmax)

   467

                    boxsizer.AddWindow(spinctrl)

   468

                    if element_infos["value"] is not None:

   469

                        spinctrl.SetValue(element_infos["value"])

   470

                    spinctrl.Bind(wx.EVT_SPINCTRL,

   471

                                  self.GetTextCtrlCallBackFunction(spinctrl, element_path),

   472

                                  spinctrl)

   473

   474

                else:

   475

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

   476

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

   477

                        boxsizer.AddWindow(checkbox)

   478

                        if element_infos["value"] is not None:

   479

                            checkbox.SetValue(element_infos["value"])

   480

                        checkbox.Bind(wx.EVT_CHECKBOX,

   481

                                      self.GetCheckBoxCallBackFunction(checkbox, element_path),

   482

                                      checkbox)

   483

   484

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

   485

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

   486

                            scmin = 0

   487

                        else:

   488

                            scmin = -(2**31)

   489

                        scmax = 2**31-1

   490

                        spinctrl = wx.SpinCtrl(self.ParamsEditor,

   491

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