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) 2013: 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 wx

    30

    31

from plcopen.structures import TestIdentifier, IEC_KEYWORDS

    32

from graphics.GraphicCommons import FREEDRAWING_MODE

    33

    34

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

    35

#                    Dialog with preview for graphic block

    36

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

    37

    38

    39

class BlockPreviewDialog(wx.Dialog):

    40

    """

    41

    Class that implements a generic dialog containing a preview panel for displaying

    42

    graphic created by dialog

    43

    """

    44

    45

    def __init__(self, parent, controller, tagname, title):

    46

        """

    47

        Constructor

    48

        @param parent: Parent wx.Window of dialog for modal

    49

        @param controller: Reference to project controller

    50

        @param tagname: Tagname of project POU edited

    51

        @param title: Title of dialog frame

    52

        """

    53

        wx.Dialog.__init__(self, parent, title=title)

    54

    55

        # Save reference to

    56

        self.Controller = controller

    57

        self.TagName = tagname

    58

    59

        # Label for preview

    60

        self.PreviewLabel = wx.StaticText(self, label=_('Preview:'))

    61

    62

        # Create Preview panel

    63

        self.Preview = wx.Panel(self, style=wx.SIMPLE_BORDER)

    64

        self.Preview.SetBackgroundColour(wx.WHITE)

    65

    66

        # Add function to preview panel so that it answers to graphic elements

    67

        # like Viewer

    68

        setattr(self.Preview, "GetDrawingMode", lambda: FREEDRAWING_MODE)

    69

        setattr(self.Preview, "GetScaling", lambda: None)

    70

        setattr(self.Preview, "GetBlockType", controller.GetBlockType)

    71

        setattr(self.Preview, "IsOfType", controller.IsOfType)

    72

    73

        # Bind paint event on Preview panel

    74

        self.Preview.Bind(wx.EVT_PAINT, self.OnPaint)

    75

    76

        # Add default dialog buttons sizer

    77

        self.ButtonSizer = self.CreateButtonSizer(wx.OK | wx.CANCEL | wx.CENTRE)

    78

        self.Bind(wx.EVT_BUTTON, self.OnOK,

    79

                  self.ButtonSizer.GetAffirmativeButton())

    80

    81

        self.Element = None            # Graphic element to display in preview

    82

        self.MinElementSize = None     # Graphic element minimal size

    83

    84

        # Variable containing the graphic element name when dialog is opened

    85

        self.DefaultElementName = None

    86

        self.Fit()

    87

    88

        # List of variables defined in POU {var_name: (var_class, var_type),...}

    89

        self.VariableList = {}

    90

    91

    def __del__(self):

    92

        """

    93

        Destructor

    94

        """

    95

        # Remove reference to project controller

    96

        self.Controller = None

    97

    98

    def _init_sizers(self,

    99

                     main_rows, main_growable_row,

   100

                     left_rows, left_growable_row,

   101

                     right_rows, right_growable_row):

   102

        """

   103

        Initialize common sizers

   104

        @param main_rows: Number of rows in main sizer

   105

        @param main_growable_row: Row that is growable in main sizer, None if no

   106

        row is growable

   107

        @param left_rows: Number of rows in left grid sizer

   108

        @param left_growable_row: Row that is growable in left grid sizer, None

   109

        if no row is growable

   110

        @param right_rows: Number of rows in right grid sizer

   111

        @param right_growable_row: Row that is growable in right grid sizer,

   112

        None if no row is growable

   113

        """

   114

        # Create dialog main sizer

   115

        self.MainSizer = wx.FlexGridSizer(cols=1, hgap=0,

   116

                                          rows=main_rows, vgap=10)

   117

        self.MainSizer.AddGrowableCol(0)

   118

        if main_growable_row is not None:

   119

            self.MainSizer.AddGrowableRow(main_growable_row)

   120

   121

        # Create a sizer for dividing parameters in two columns

   122

        self.ColumnSizer = wx.BoxSizer(wx.HORIZONTAL)

   123

        self.MainSizer.AddSizer(self.ColumnSizer, border=20,

   124

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

   125

   126

        # Create a sizer for left column

   127

        self.LeftGridSizer = wx.FlexGridSizer(cols=1, hgap=0,

   128

                                              rows=left_rows, vgap=5)

   129

        self.LeftGridSizer.AddGrowableCol(0)

   130

        if left_growable_row is not None:

   131

            self.LeftGridSizer.AddGrowableRow(left_growable_row)

   132

        self.ColumnSizer.AddSizer(self.LeftGridSizer, 1, border=5,

   133

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

   134

   135

        # Create a sizer for right column

   136

        self.RightGridSizer = wx.FlexGridSizer(cols=1, hgap=0,

   137

                                               rows=right_rows, vgap=0)

   138

        self.RightGridSizer.AddGrowableCol(0)

   139

        if right_growable_row is not None:

   140

            self.RightGridSizer.AddGrowableRow(right_growable_row)

   141

        self.ColumnSizer.AddSizer(self.RightGridSizer, 1, border=5,

   142

                                  flag=wx.GROW | wx.LEFT)

   143

   144

        self.SetSizer(self.MainSizer)

   145

   146

    def SetMinElementSize(self, size):

   147

        """

   148

        Define minimal graphic element size

   149

        @param size: Tuple containing minimal size (width, height)

   150

        """

   151

        self.MinElementSize = size

   152

   153

    def GetMinElementSize(self):

   154

        """

   155

        Get minimal graphic element size

   156

        @return: Tuple containing minimal size (width, height) or None if no

   157

        element defined

   158

        May be overridden by inherited classes

   159

        """

   160

        if self.Element is None:

   161

            return None

   162

   163

        return self.Element.GetMinSize()

   164

   165

    def SetPreviewFont(self, font):

   166

        """

   167

        Set font of Preview panel

   168

        @param font: wx.Font object containing font style

   169

        """

   170

        self.Preview.SetFont(font)

   171

   172

    def RefreshVariableList(self):

   173

        """

   174

        Extract list of variables defined in POU

   175

        """

   176

        # Get list of variables defined in POU

   177

        self.VariableList = {

   178

            var.Name: (var.Class, var.Type)

   179

            for var in self.Controller.GetEditedElementInterfaceVars(self.TagName)

   180

            if var.Edit}

   181

   182

        # Add POU name to variable list if POU is a function

   183

        returntype = self.Controller.GetEditedElementInterfaceReturnType(self.TagName)

   184

        if returntype is not None:

   185

            self.VariableList[

   186

                self.Controller.GetEditedElementName(self.TagName)] = \

   187

                 ("Output", returntype)

   188

   189

        # Add POU name if POU is a transition

   190

        words = self.TagName.split("::")

   191

        if words[0] == "T":

   192

            self.VariableList[words[2]] = ("Output", "BOOL")

   193

   194

    def TestElementName(self, element_name):

   195

        """

   196

        Test displayed graphic element name

   197

        @param element_name: Graphic element name

   198

        """

   199

        # Variable containing error message format

   200

        message_format = None

   201

        # Get graphic element name in upper case

   202

        uppercase_element_name = element_name.upper()

   203

   204

        # Test if graphic element name is a valid identifier

   205

        if not TestIdentifier(element_name):

   206

            message_format = _("\"%s\" is not a valid identifier!")

   207

   208

        # Test that graphic element name isn't a keyword

   209

        elif uppercase_element_name in IEC_KEYWORDS:

   210

            message_format = _("\"%s\" is a keyword. It can't be used!")

   211

   212

        # Test that graphic element name isn't a POU name

   213

        elif uppercase_element_name in self.Controller.GetProjectPouNames():

   214

            message_format = _("\"%s\" pou already exists!")

   215

   216

        # Test that graphic element name isn't already used in POU by a variable

   217

        # or another graphic element

   218

        elif ((self.DefaultElementName is None or

   219

               self.DefaultElementName.upper() != uppercase_element_name) and

   220

              uppercase_element_name in self.Controller.GetEditedElementVariables(self.TagName)):

   221

            message_format = _("\"%s\" element for this pou already exists!")

   222

   223

        # If an error have been identify, show error message dialog

   224

        if message_format is not None:

   225

            self.ShowErrorMessage(message_format % element_name)

   226

            # Test failed

   227

            return False

   228

   229

        # Test succeed

   230

        return True

   231

   232

    def ShowErrorMessage(self, message):

   233

        """

   234

        Show an error message dialog over this dialog

   235

        @param message: Error message to display

   236

        """

   237

        dialog = wx.MessageDialog(self, message,

   238

                                  _("Error"),

   239

                                  wx.OK | wx.ICON_ERROR)

   240

        dialog.ShowModal()

   241

        dialog.Destroy()

   242

   243

    def OnOK(self, event):

   244

        """

   245

        Called when dialog OK button is pressed

   246

        Need to be overridden by inherited classes to check that dialog values

   247

        are valid

   248

        @param event: wx.Event from OK button

   249

        """

   250

        # Close dialog

   251

        self.EndModal(wx.ID_OK)

   252

   253

    def RefreshPreview(self):

   254

        """Triggers EVT_PAINT event to refresh UI"""

   255

        self.Refresh()

   256

   257

    def DrawPreview(self):

   258

        """

   259

        Refresh preview panel of graphic element

   260

        May be overridden by inherited classes

   261

        """

   262

        # Init preview panel paint device context

   263

        dc = wx.PaintDC(self.Preview)

   264

        dc.SetFont(self.Preview.GetFont())

   265

        dc.Clear()

   266

   267

        # Return immediately if no graphic element defined

   268

        if self.Element is None:

   269

            return

   270

   271

        # Calculate block size according to graphic element min size due to its

   272

        # parameters and graphic element min size defined

   273

        min_width, min_height = self.GetMinElementSize()

   274

        width = max(self.MinElementSize[0], min_width)

   275

        height = max(self.MinElementSize[1], min_height)

   276

        self.Element.SetSize(width, height)

   277

   278

        # Get element position and bounding box to center in preview

   279

        posx, posy = self.Element.GetPosition()

   280

        bbox = self.Element.GetBoundingBox()

   281

   282

        # Get Preview panel size

   283

        client_size = self.Preview.GetClientSize()

   284

   285

        # If graphic element is too big to be displayed in preview panel,

   286

        # calculate preview panel scale so that graphic element fit inside

   287

        k = 1.1 if (bbox.width * 1.1 > client_size.width or

   288

                    bbox.height * 1.1 > client_size.height) \

   289

            else 1.0

   290

        scale = (max(bbox.width / client_size.width,

   291

                     bbox.height / client_size.height) * k)

   292

        dc.SetUserScale(1.0 / scale, 1.0 / scale)

   293

   294

        # Center graphic element in preview panel

   295

        x = int(client_size.width * scale - bbox.width) // 2 + posx - bbox.x

   296

        y = int(client_size.height * scale - bbox.height) // 2 + posy - bbox.y

   297

        self.Element.SetPosition(x, y)

   298

   299

        # Draw graphic element

   300

        self.Element.Draw(dc)

   301

   302

    def OnPaint(self, event):

   303

        """

   304

        Called when Preview panel need to be redraw

   305

        @param event: wx.PaintEvent

   306

        """

   307

        self.DrawPreview()

   308

        event.Skip()