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

import wx

    27

    28

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

    29

#                                 Helpers

    30

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

    31

    32

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

    33

    37

] = range(10)

    38

    39

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

    40

#                       Project Properties Panel

    41

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

    42

    43

    44

class ProjectPropertiesPanel(wx.Notebook):

    45

    46

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

    47

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

    48

            border = 0

    49

            if idx == 0:

    50

                border |= wx.TOP

    51

            elif idx == len(params) - 1:

    52

                border |= wx.BOTTOM

    53

    54

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

    55

            sizer.AddWindow(st, border=10,

    56

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

    57

    58

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

    59

            setattr(self, name, tc)

    60

            callback = self.GetTextCtrlChangedFunction(tc, name)

    61

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

    62

            tc.Bind(wx.EVT_KILL_FOCUS, callback)

    63

            sizer.AddWindow(tc, border=10,

    64

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

    65

    66

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

    67

        wx.Notebook.__init__(self, parent)

    68

    69

        self.Controller = controller

    70

        self.ParentWindow = window

    71

        self.Values = None

    72

    73

        # Project Panel elements

    74

    75

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

    76

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

    77

        projectpanel_sizer.AddGrowableCol(1)

    78

        self.ProjectPanel.SetSizer(projectpanel_sizer)

    79

    80

        self.AddSizerParams(self.ProjectPanel, projectpanel_sizer,

    81

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

    82

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

    83

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

    84

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

    85

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

    86

    87

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

    88

    89

        # Author Panel elements

    90

    91

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

    92

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

    93

        authorpanel_sizer.AddGrowableCol(1)

    94

        self.AuthorPanel.SetSizer(authorpanel_sizer)

    95

    96

        self.AddSizerParams(self.AuthorPanel, authorpanel_sizer,

    97

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

    98

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

    99

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

   100

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

   101

   102

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

   103

   104

        # Graphics Panel elements

   105

   106

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

   107

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

   108

        graphicpanel_sizer.AddGrowableCol(0)

   109

        graphicpanel_sizer.AddGrowableRow(3)

   110

        self.GraphicsPanel.SetSizer(graphicpanel_sizer)

   111

   112

        pageSize_st = wx.StaticText(self.GraphicsPanel,

   113

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

   114

        graphicpanel_sizer.AddWindow(

   115

            pageSize_st, border=10,

   116

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

   117

   118

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

   119

        pageSize_sizer.AddGrowableCol(1)

   120

        graphicpanel_sizer.AddSizer(pageSize_sizer, border=10,

   121

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

   122

   123

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

   124

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

   125

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

   126

            pageSize_sizer.AddWindow(st, border=12,

   127

                                     flag=wx.ALIGN_CENTER_VERTICAL | wx.LEFT)

   128

   129

            sp = wx.SpinCtrl(self.GraphicsPanel,

   130

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

   131

            setattr(self, name, sp)

   132

            callback = self.GetPageSizeChangedFunction(sp, name)

   133

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

   134

            sp.Bind(wx.EVT_KILL_FOCUS, callback)

   135

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

   136

   137

        scaling_st = wx.StaticText(self.GraphicsPanel,

   138

                                   label=_('Grid Resolution:'))

   139

        graphicpanel_sizer.AddWindow(scaling_st, border=10,

   140

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

   141

   142

        scaling_nb = wx.Notebook(self.GraphicsPanel)

   143

        graphicpanel_sizer.AddWindow(scaling_nb, border=10,

   144

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

   145

   146

        self.Scalings = {}

   147

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

   148

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

   149

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

   150

            scalingpanel_sizer.AddGrowableCol(1)

   151

            scaling_panel.SetSizer(scalingpanel_sizer)

   152

   153

            scaling_controls = []

   154

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

   155

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

   156

                if idx == 0:

   157

                    border = wx.TOP

   158

                else:

   159

                    border = wx.BOTTOM

   160

   161

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

   162

                scalingpanel_sizer.AddWindow(

   163

                    st, border=10,

   164

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

   165

   166

                sp = wx.SpinCtrl(scaling_panel,

   167

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

   168

                scaling_controls.append(sp)

   169

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

   170

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

   171

                sp.Bind(wx.EVT_KILL_FOCUS, callback)

   172

                scalingpanel_sizer.AddWindow(sp, border=10,

   173

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

   174

   175

            self.Scalings[language] = scaling_controls

   176

            scaling_nb.AddPage(scaling_panel, translation)

   177

   178

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

   179

   180

        # Miscellaneous Panel elements

   181

   182

        self.MiscellaneousPanel = wx.Panel(

   183

            id=-1, parent=self, name='MiscellaneousPanel', pos=wx.Point(0, 0),

   184

            size=wx.Size(0, 0), style=wx.TAB_TRAVERSAL)

   185

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

   186

        miscellaneouspanel_sizer.AddGrowableCol(1)

   187

        miscellaneouspanel_sizer.AddGrowableRow(1)

   188

        self.MiscellaneousPanel.SetSizer(miscellaneouspanel_sizer)

   189

   190

        language_label = wx.StaticText(self.MiscellaneousPanel,

   191

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

   192

        miscellaneouspanel_sizer.AddWindow(language_label, border=10,

   193

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

   194

   195

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

   196

                                    style=wx.CB_READONLY)

   197

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

   198

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

   199

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

   200

   201

        description_label = wx.StaticText(

   202

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

   203

        miscellaneouspanel_sizer.AddWindow(description_label, border=10,

   204

                                           flag=wx.BOTTOM | wx.LEFT)

   205

   206

        self.ContentDescription = wx.TextCtrl(

   207

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

   208

            style=wx.TE_MULTILINE | wx.TE_PROCESS_ENTER)

   209

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

   210

                  self.ContentDescription)

   211

        self.ContentDescription.Bind(wx.EVT_KILL_FOCUS,

   212

                                     self.OnContentDescriptionChanged)

   213

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

   214

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

   215

   216

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

   217

   218

        for param in REQUIRED_PARAMS:

   219

            getattr(self, param).Enable(enable_required)

   220

   221

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

   222

   223

        for language in languages:

   224

            self.Language.Append(language)

   225

   226

    def RefreshView(self):

   227

        if self.Controller is not None:

   228

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

   229

   230

    def SetValues(self, values):

   231

        self.Values = values

   232

        for item, value in values.items():

   233

            if item == "language":

   234

                self.Language.SetStringSelection(value)

   235

            elif item == "contentDescription":

   236

                self.ContentDescription.SetValue(value)

   237

            elif item == "pageSize":

   238

                self.PageWidth.SetValue(value[0])

   239

                self.PageHeight.SetValue(value[1])

   240

            elif item == "scaling":

   241

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

   242

                    if language in self.Scalings:

   243

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

   244

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

   245

            else:

   246

                tc = getattr(self, item, None)

   247

                if tc is not None:

   248

                    tc.SetValue(value)

   249

   250

    def GetValues(self):

   251

        values = {}

   252

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

   253

                      "productName", "productVersion",

   254

                      "productRelease", "companyName",

   255

                      "companyURL", "authorName",

   256

                      "organization"]:

   257

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

   258

            if param in REQUIRED_PARAMS or value != "":

   259

                values[param] = value

   260

            else:

   261

                values[param] = None

   262

        language = self.Language.GetStringSelection()

   263

        if language != "":

   264

            values["language"] = language

   265

        else:

   266

            values["language"] = None

   267

        content_description = self.ContentDescription.GetValue()

   268

        if content_description != "":

   269

            values["contentDescription"] = content_description

   270

        else:

   271

            values["contentDescription"] = None

   272

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

   273

        values["scaling"] = {}

   274

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

   275

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

   276

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

   277

        return values

   278

   279

    def GetTextCtrlChangedFunction(self, textctrl, name):

   280

        def TextCtrlChangedFunction(event):

   281

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

   282

                old_value = self.Values.get(name)

   283

                new_value = textctrl.GetValue()

   284

                if name not in REQUIRED_PARAMS and new_value == "":

   285

                    new_value = None

   286

                if old_value != new_value:

   287

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

   288

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

   289

                                               PROJECTTREE, PAGETITLES)

   290

                    wx.CallAfter(self.RefreshView)

   291

            event.Skip()

   292

        return TextCtrlChangedFunction

   293

   294

    def GetPageSizeChangedFunction(self, spinctrl, name):

   295

        def PageSizeChangedFunction(event):

   296

            if self.Controller is not None:

   297

                if self.Values is not None:

   298

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

   299

                else:

   300

                    old_value = (0, 0)

   301

                if name == 'PageWidth':

   302

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

   303

                else:

   304

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

   305

                if old_value != new_value:

   306

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

   307

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

   308

                                               PAGETITLES, SCALING)

   309

                    wx.CallAfter(self.RefreshView)

   310

            event.Skip()

   311

        return PageSizeChangedFunction

   312

   313

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

   314

        def ScalingChangedFunction(event):

   315

            if self.Controller is not None:

   316

                old_value = (0, 0)

   317

                if self.Values is not None:

   318

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

   319

                    if scaling is not None:

   320

                        old_value = scaling.get(language)

   321

                if name == 'XScale':

   322

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

   323

                else:

   324

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

   325

                if old_value != new_value:

   326

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

   327

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

   328

                                               PAGETITLES, SCALING)

   329

                    wx.CallAfter(self.RefreshView)

   330

            event.Skip()

   331

        return ScalingChangedFunction

   332

   333

    def OnLanguageChanged(self, event):

   334

        if self.Controller is not None:

   335

            if self.Values is not None:

   336

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

   337

            else:

   338

                old_value = None

   339

            new_value = self.Language.GetStringSelection()

   340

            if new_value == "":

   341

                new_value = None

   342

            if old_value != new_value:

   343

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

   344

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

   345

                wx.CallAfter(self.RefreshView)

   346

        event.Skip()

   347

   348

    def OnContentDescriptionChanged(self, event):

   349

        if self.Controller is not None:

   350

            if self.Values is not None:

   351

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

   352

            else:

   353

                old_value = None

   354

            new_value = self.ContentDescription.GetValue()

   355

            if new_value == "":

   356

                new_value = None

   357

            if old_value != new_value:

   358

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

   359

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

   360

                wx.CallAfter(self.RefreshView)

   361

        event.Skip()