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) 2012: 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

from __future__ import absolute_import

    27

import wx

    28

from wx.lib.scrolledpanel import ScrolledPanel

    29

    30

from xmlclass.xmlclass import URI_model

    31

    32

# -------------------------------------------------------------------------------

    33

#                                 Helpers

    34

# -------------------------------------------------------------------------------

    35

    36

REQUIRED_PARAMS = ["projectName", "productName", "productVersion", "companyName"]

    37

    38

[

    39

    TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, PROJECTTREE,

    40

    POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

    41

] = range(10)

    42

    43

    44

# -------------------------------------------------------------------------------

    45

#                       Project Properties Panel

    46

# -------------------------------------------------------------------------------

    47

    48

    49

class ProjectPropertiesPanel(wx.Notebook):

    50

    51

    def AddSizerParams(self, parent, sizer, params):

    52

        for idx, (name, label) in enumerate(params):

    53

            border = 0

    54

            if idx == 0:

    55

                border |= wx.TOP

    56

            elif idx == len(params) - 1:

    57

                border |= wx.BOTTOM

    58

    59

            st = wx.StaticText(parent, label=label)

    60

            sizer.Add(st, border=10,

    61

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

    62

    63

            tc = wx.TextCtrl(parent, style=wx.TE_PROCESS_ENTER)

    64

            setattr(self, name, tc)

    65

            callback = self.GetTextCtrlChangedFunction(tc, name)

    66

            self.Bind(wx.EVT_TEXT_ENTER, callback, tc)

    67

            tc.Bind(wx.EVT_KILL_FOCUS, callback)

    68

            sizer.Add(tc, border=10,

    69

                            flag=wx.GROW | border | wx.RIGHT)

    70

    71

    def __init__(self, parent, controller=None, window=None, enable_required=True, scrolling=True):

    72

        wx.Notebook.__init__(self, parent)

    73

    74

        self.Controller = controller

    75

        self.ParentWindow = window

    76

        self.Values = None

    77

    78

        # Project Panel elements

    79

    80

        self.ProjectPanel = ScrolledPanel(self, style=wx.TAB_TRAVERSAL)

    81

        self.ProjectPanel.SetAutoLayout(1)

    82

        if scrolling:

    83

            self.ProjectPanel.SetupScrolling()

    84

        projectpanel_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=5, vgap=15)

    85

        projectpanel_sizer.AddGrowableCol(1)

    86

        self.ProjectPanel.SetSizer(projectpanel_sizer)

    87

    88

        self.AddSizerParams(self.ProjectPanel, projectpanel_sizer,

    89

                            [("projectName",    _('Project Name (required):')),

    90

                             ("projectVersion", _('Project Version (optional):')),

    91

                             ("productName",    _('Product Name (required):')),

    92

                             ("productVersion", _('Product Version (required):')),

    93

                             ("productRelease", _('Product Release (optional):'))])

    94

    95

        self.AddPage(self.ProjectPanel, _("Project"))

    96

    97

        # Author Panel elements

    98

    99

        self.AuthorPanel = ScrolledPanel(self, style=wx.TAB_TRAVERSAL)

   100

        self.AuthorPanel.SetAutoLayout(1)

   101

        if scrolling:

   102

            self.AuthorPanel.SetupScrolling()

   103

        authorpanel_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=4, vgap=15)

   104

        authorpanel_sizer.AddGrowableCol(1)

   105

        self.AuthorPanel.SetSizer(authorpanel_sizer)

   106

   107

        self.AddSizerParams(self.AuthorPanel, authorpanel_sizer,

   108

                            [("companyName",  _('Company Name (required):')),

   109

                             ("companyURL",   _('Company URL (optional):')),

   110

                             ("authorName",   _('Author Name (optional):')),

   111

                             ("organization", _('Organization (optional):'))])

   112

   113

        self.AddPage(self.AuthorPanel, _("Author"))

   114

   115

        # Graphics Panel elements

   116

   117

        self.GraphicsPanel = ScrolledPanel(self, style=wx.TAB_TRAVERSAL)

   118

        self.GraphicsPanel.SetAutoLayout(1)

   119

        if scrolling:

   120

            self.GraphicsPanel.SetupScrolling()

   121

        graphicpanel_sizer = wx.FlexGridSizer(cols=1, hgap=5, rows=4, vgap=5)

   122

        graphicpanel_sizer.AddGrowableCol(0)

   123

        graphicpanel_sizer.AddGrowableRow(3)

   124

        self.GraphicsPanel.SetSizer(graphicpanel_sizer)

   125

   126

        pageSize_st = wx.StaticText(self.GraphicsPanel,

   127

                                    label=_('Page Size (optional):'))

   128

        graphicpanel_sizer.Add(

   129

            pageSize_st, border=10,

   130

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

   131

   132

        pageSize_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=2, vgap=5)

   133

        pageSize_sizer.AddGrowableCol(1)

   134

        graphicpanel_sizer.Add(pageSize_sizer, border=10,

   135

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

   136

   137

        for name, label in [('PageWidth', _('Width:')),

   138

                            ('PageHeight', _('Height:'))]:

   139

            st = wx.StaticText(self.GraphicsPanel, label=label)

   140

            pageSize_sizer.Add(st, border=12,

   141

                                     flag=wx.ALIGN_CENTER_VERTICAL | wx.LEFT)

   142

   143

            sp = wx.SpinCtrl(self.GraphicsPanel,

   144

                             min=0, max=2**16, style=wx.TE_PROCESS_ENTER)

   145

            setattr(self, name, sp)

   146

            callback = self.GetPageSizeChangedFunction(sp, name)

   147

            self.Bind(wx.EVT_TEXT_ENTER, callback, sp)

   148

            sp.Bind(wx.EVT_KILL_FOCUS, callback)

   149

            pageSize_sizer.Add(sp, flag=wx.GROW)

   150

   151

        scaling_st = wx.StaticText(self.GraphicsPanel,

   152

                                   label=_('Grid Resolution:'))

   153

        graphicpanel_sizer.Add(scaling_st, border=10,

   154

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

   155

   156

        scaling_nb = wx.Notebook(self.GraphicsPanel)

   157

        graphicpanel_sizer.Add(scaling_nb, border=10,

   158

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

   159

   160

        self.Scalings = {}

   161

        for language, translation in [("FBD", _("FBD")), ("LD", _("LD")), ("SFC", _("SFC"))]:

   162

            scaling_panel = wx.Panel(scaling_nb, style=wx.TAB_TRAVERSAL)

   163

            scalingpanel_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=2, vgap=5)

   164

            scalingpanel_sizer.AddGrowableCol(1)

   165

            scaling_panel.SetSizer(scalingpanel_sizer)

   166

   167

            scaling_controls = []

   168

            for idx, (name, label) in enumerate([('XScale', _('Horizontal:')),

   169

                                                 ('YScale', _('Vertical:'))]):

   170

                if idx == 0:

   171

                    border = wx.TOP

   172

                else:

   173

                    border = wx.BOTTOM

   174

   175

                st = wx.StaticText(scaling_panel, label=label)

   176

                scalingpanel_sizer.Add(

   177

                    st, border=10,

   178

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

   179

   180

                sp = wx.SpinCtrl(scaling_panel,

   181

                                 min=0, max=2**16, style=wx.TE_PROCESS_ENTER)

   182

                scaling_controls.append(sp)

   183

                callback = self.GetScalingChangedFunction(sp, language, name)

   184

                self.Bind(wx.EVT_TEXT_ENTER, callback, sp)

   185

                sp.Bind(wx.EVT_KILL_FOCUS, callback)

   186

                scalingpanel_sizer.Add(sp, border=10,

   187

                                             flag=wx.GROW | border | wx.RIGHT)

   188

   189

            self.Scalings[language] = scaling_controls

   190

            scaling_nb.AddPage(scaling_panel, translation)

   191

   192

        self.AddPage(self.GraphicsPanel, _("Graphics"))

   193

   194

        # Miscellaneous Panel elements

   195

   196

        self.MiscellaneousPanel = ScrolledPanel(parent=self,

   197

                                                name='MiscellaneousPanel',

   198

                                                style=wx.TAB_TRAVERSAL)

   199

        self.MiscellaneousPanel.SetAutoLayout(1)

   200

        if scrolling:

   201

            self.MiscellaneousPanel.SetupScrolling()

   202

        miscellaneouspanel_sizer = wx.FlexGridSizer(cols=2, hgap=5, rows=2, vgap=15)

   203

        miscellaneouspanel_sizer.AddGrowableCol(1)

   204

        miscellaneouspanel_sizer.AddGrowableRow(1)

   205

        self.MiscellaneousPanel.SetSizer(miscellaneouspanel_sizer)

   206

   207

        language_label = wx.StaticText(self.MiscellaneousPanel,

   208

                                       label=_('Language (optional):'))

   209

        miscellaneouspanel_sizer.Add(language_label, border=10,

   210

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

   211

   212

        self.Language = wx.ComboBox(self.MiscellaneousPanel,

   213

                                    style=wx.CB_READONLY)

   214

        self.Bind(wx.EVT_COMBOBOX, self.OnLanguageChanged, self.Language)

   215

        miscellaneouspanel_sizer.Add(self.Language, border=10,

   216

                                           flag=wx.GROW | wx.TOP | wx.RIGHT)

   217

   218

        description_label = wx.StaticText(

   219

            self.MiscellaneousPanel, label=_('Content Description (optional):'))

   220

        miscellaneouspanel_sizer.Add(description_label, border=10,

   221

                                           flag=wx.BOTTOM | wx.LEFT)

   222

   223

        self.ContentDescription = wx.TextCtrl(

   224

            self.MiscellaneousPanel, size=wx.Size(240, 150),

   225

            style=wx.TE_MULTILINE | wx.TE_PROCESS_ENTER)

   226

        self.Bind(wx.EVT_TEXT_ENTER, self.OnContentDescriptionChanged,

   227

                  self.ContentDescription)

   228

        self.ContentDescription.Bind(wx.EVT_KILL_FOCUS,

   229

                                     self.OnContentDescriptionChanged)

   230

        miscellaneouspanel_sizer.Add(self.ContentDescription, border=10,

   231

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

   232

   233

        self.AddPage(self.MiscellaneousPanel, _("Miscellaneous"))

   234

   235

        for param in REQUIRED_PARAMS:

   236

            getattr(self, param).Enable(enable_required)

   237

   238

        languages = ["", "en-US", "fr-FR", "zh-CN", "ru-RU"]

   239

   240

        for language in languages:

   241

            self.Language.Append(language)

   242

   243

    def RefreshView(self):

   244

        if self.Controller is not None:

   245

            self.SetValues(self.Controller.GetProjectProperties())

   246

   247

    def SetValues(self, values):

   248

        self.Values = values

   249

        for item, value in values.items():

   250

            if item == "language":

   251

                self.Language.SetStringSelection(value)

   252

            elif item == "contentDescription":

   253

                self.ContentDescription.SetValue(value)

   254

            elif item == "pageSize":

   255

                self.PageWidth.SetValue(value[0])

   256

                self.PageHeight.SetValue(value[1])

   257

            elif item == "scaling":

   258

                for language, (x, y) in value.items():

   259

                    if language in self.Scalings:

   260

                        self.Scalings[language][0].SetValue(x)

   261

                        self.Scalings[language][1].SetValue(y)

   262

            else:

   263

                tc = getattr(self, item, None)

   264

                if tc is not None:

   265

                    tc.SetValue(value)

   266

   267

    def GetValues(self):

   268

        values = {}

   269

        for param in ["projectName", "projectVersion",

   270

                      "productName", "productVersion",

   271

                      "productRelease", "companyName",

   272

                      "companyURL", "authorName",

   273

                      "organization"]:

   274

            value = getattr(self, param).GetValue()

   275

            if param in REQUIRED_PARAMS or value != "":

   276

                values[param] = value

   277

            else:

   278

                values[param] = None

   279

        language = self.Language.GetStringSelection()

   280

        if language != "":

   281

            values["language"] = language

   282

        else:

   283

            values["language"] = None

   284

        content_description = self.ContentDescription.GetValue()

   285

        if content_description != "":

   286

            values["contentDescription"] = content_description

   287

        else:

   288

            values["contentDescription"] = None

   289

        values["pageSize"] = (self.PageWidth.GetValue(), self.PageHeight.GetValue())

   290

        values["scaling"] = {}

   291

        for language in ["FBD", "LD", "SFC"]:

   292

            values["scaling"][language] = (self.Scalings[language][0].GetValue(),

   293

                                           self.Scalings[language][1].GetValue())

   294

        return values

   295

   296

    def GetTextCtrlChangedFunction(self, textctrl, name):

   297

        def TextCtrlChangedFunction(event):

   298

            if self.Controller is not None and self.Values is not None:

   299

                old_value = self.Values.get(name)

   300

                new_value = textctrl.GetValue()

   301

                if name in REQUIRED_PARAMS and new_value == "":

   302

                    new_value = None

   303

                if name == 'companyURL':

   304

                    if not URI_model.match(new_value):

   305

                        new_value = None

   306

                        dialog = wx.MessageDialog(self, _('Invalid URL!\n'

   307

                                                          'Please enter correct URL address.'),

   308

                                                  _("Error"), wx.OK | wx.ICON_ERROR)

   309

                        dialog.ShowModal()

   310

                        dialog.Destroy()

   311

                if old_value != new_value:

   312

                    self.Controller.SetProjectProperties(properties={name: new_value})

   313

                    self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU,

   314

                                               PROJECTTREE, PAGETITLES)

   315

                    wx.CallAfter(self.RefreshView)

   316

            event.Skip()

   317

        return TextCtrlChangedFunction

   318

   319

    def GetPageSizeChangedFunction(self, spinctrl, name):

   320

        def PageSizeChangedFunction(event):

   321

            if self.Controller is not None:

   322

                if self.Values is not None:

   323

                    old_value = self.Values.get("pageSize")

   324

                else:

   325

                    old_value = (0, 0)

   326

                if name == 'PageWidth':

   327

                    new_value = (spinctrl.GetValue(), old_value[1])

   328

                else:

   329

                    new_value = (old_value[0], spinctrl.GetValue())

   330

                if old_value != new_value:

   331

                    self.Controller.SetProjectProperties(properties={"pageSize": new_value})

   332

                    self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU,

   333

                                               PAGETITLES, SCALING)

   334

                    wx.CallAfter(self.RefreshView)

   335

            event.Skip()

   336

        return PageSizeChangedFunction

   337

   338

    def GetScalingChangedFunction(self, spinctrl, language, name):

   339

        def ScalingChangedFunction(event):

   340

            if self.Controller is not None:

   341

                old_value = (0, 0)

   342

                if self.Values is not None:

   343

                    scaling = self.Values.get("scaling")

   344

                    if scaling is not None:

   345

                        old_value = scaling.get(language)

   346

                if name == 'XScale':

   347

                    new_value = (spinctrl.GetValue(), old_value[1])

   348

                else:

   349

                    new_value = (old_value[0], spinctrl.GetValue())

   350

                if old_value != new_value:

   351

                    self.Controller.SetProjectProperties(properties={"scaling": {language: new_value}})

   352

                    self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU,

   353

                                               PAGETITLES, SCALING)

   354

                    wx.CallAfter(self.RefreshView)

   355

            event.Skip()

   356

        return ScalingChangedFunction

   357

   358

    def OnLanguageChanged(self, event):

   359

        if self.Controller is not None:

   360

            if self.Values is not None:

   361

                old_value = self.Values.get("language")

   362

            else:

   363

                old_value = None

   364

            new_value = self.Language.GetStringSelection()

   365

            if new_value == "":

   366

                new_value = None

   367

            if old_value != new_value:

   368

                self.Controller.SetProjectProperties(properties={"language": new_value})

   369

                self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU, PAGETITLES)

   370

                wx.CallAfter(self.RefreshView)

   371

        event.Skip()

   372

   373

    def OnContentDescriptionChanged(self, event):

   374

        if self.Controller is not None:

   375

            if self.Values is not None:

   376

                old_value = self.Values.get("contentDescription")

   377

            else:

   378

                old_value = None

   379

            new_value = self.ContentDescription.GetValue()

   380

            if new_value == "":

   381

                new_value = None

   382

            if old_value != new_value:

   383

                self.Controller.SetProjectProperties(properties={"contentDescription": new_value})

   384

                self.ParentWindow._Refresh(TITLE, FILEMENU, EDITMENU, PAGETITLES)

   385

                wx.CallAfter(self.RefreshView)

   386

        event.Skip()