beremiz: comparison dialogs/BlockPreviewDialog.py

equal deleted inserted replaced

-:d51af006fa6b
+:64d8f52bc8c8
 Class that implements a generic dialog containing a preview panel for displaying
 graphic created by dialog
 """
 class BlockPreviewDialog(wx.Dialog):
 def __init__(self, parent, controller, tagname, title):
 """
 Constructor
 @param parent: Parent wx.Window of dialog for modal
 @param controller: Reference to project controller
 @param tagname: Tagname of project POU edited
 @param title: Title of dialog frame
 """
 wx.Dialog.__init__(self, parent, title=title)
 # Save reference to
 self.Controller = controller
 self.TagName = tagname
 # Label for preview
 self.PreviewLabel = wx.StaticText(self, label=_('Preview:'))
 # Create Preview panel
 self.Preview = wx.Panel(self, style=wx.SIMPLE_BORDER)
 self.Preview.SetBackgroundColour(wx.WHITE)
 # Add function to preview panel so that it answers to graphic elements
 # like Viewer
 setattr(self.Preview, "GetDrawingMode", lambda:FREEDRAWING_MODE)
 setattr(self.Preview, "GetScaling", lambda:None)
 setattr(self.Preview, "GetBlockType", controller.GetBlockType)
 setattr(self.Preview, "IsOfType", controller.IsOfType)
 # Bind paint event on Preview panel
 self.Preview.Bind(wx.EVT_PAINT, self.OnPaint)
 # Add default dialog buttons sizer
 self.ButtonSizer = self.CreateButtonSizer(wx.OK|wx.CANCEL|wx.CENTRE)
 self.Bind(wx.EVT_BUTTON, self.OnOK,
 self.ButtonSizer.GetAffirmativeButton())
 self.Element = None            # Graphic element to display in preview
 self.MinElementSize = None     # Graphic element minimal size
 # Variable containing the graphic element name when dialog is opened
 self.DefaultElementName = None
 self.Fit()
 # List of variables defined in POU {var_name: (var_class, var_type),...}
 self.VariableList = {}
 def __del__(self):
 """
 Destructor
 """
 # Remove reference to project controller
 self.Controller = None
 def _init_sizers(self, main_rows, main_growable_row,
 left_rows, left_growable_row,
 right_rows, right_growable_row):
 """
 Initialize common sizers
 @param right_rows: Number of rows in right grid sizer
 @param right_growable_row: Row that is growable in right grid sizer,
 None if no row is growable
 """
 # Create dialog main sizer
 self.MainSizer = wx.FlexGridSizer(cols=1, hgap=0,
 rows=main_rows, vgap=10)
 self.MainSizer.AddGrowableCol(0)
 if main_growable_row is not None:
 self.MainSizer.AddGrowableRow(main_growable_row)
 # Create a sizer for dividing parameters in two columns
 self.ColumnSizer = wx.BoxSizer(wx.HORIZONTAL)
 self.MainSizer.AddSizer(self.ColumnSizer, border=20,
 flag=wx.GROW|wx.TOP|wx.LEFT|wx.RIGHT)
 # Create a sizer for left column
 self.LeftGridSizer = wx.FlexGridSizer(cols=1, hgap=0,
 rows=left_rows, vgap=5)
 self.LeftGridSizer.AddGrowableCol(0)
 if left_growable_row is not None:
 self.LeftGridSizer.AddGrowableRow(left_growable_row)
 self.ColumnSizer.AddSizer(self.LeftGridSizer, 1, border=5,
 flag=wx.GROW|wx.RIGHT|wx.EXPAND)
 # Create a sizer for right column
 self.RightGridSizer = wx.FlexGridSizer(cols=1, hgap=0,
 rows=right_rows, vgap=0)
 self.RightGridSizer.AddGrowableCol(0)
 if right_growable_row is not None:
 self.RightGridSizer.AddGrowableRow(right_growable_row)
 self.ColumnSizer.AddSizer(self.RightGridSizer, 1, border=5,
 flag=wx.GROW|wx.LEFT)
 self.SetSizer(self.MainSizer)
 def SetMinElementSize(self, size):
 """
 Define minimal graphic element size
 @param size: Tuple containing minimal size (width, height)
 """
 self.MinElementSize = size
 def GetMinElementSize(self):
 """
 Get minimal graphic element size
 @return: Tuple containing minimal size (width, height) or None if no
 element defined
 May be overridden by inherited classes
 """
 if self.Element is None:
 return None
 return self.Element.GetMinSize()
 def SetPreviewFont(self, font):
 """
 Set font of Preview panel
 @param font: wx.Font object containing font style
 """
 self.Preview.SetFont(font)
 def RefreshVariableList(self):
 """
 Extract list of variables defined in POU
 """
 # Get list of variables defined in POU
 self.VariableList = {
 var.Name: (var.Class, var.Type)
 for var in self.Controller.GetEditedElementInterfaceVars(
 self.TagName)
 if var.Edit}
 # Add POU name to variable list if POU is a function
 returntype = self.Controller.GetEditedElementInterfaceReturnType(
 self.TagName)
 if returntype is not None:
 self.VariableList[
 self.Controller.GetEditedElementName(self.TagName)] = \
 ("Output", returntype)
 # Add POU name if POU is a transition
 words = self.TagName.split("::")
 if words[0] == "T":
 self.VariableList[words[2]] = ("Output", "BOOL")
 def TestElementName(self, element_name):
 """
 Test displayed graphic element name
 @param element_name: Graphic element name
 """
 # Variable containing error message format
 message_format = None
 # Get graphic element name in upper case
 uppercase_element_name = element_name.upper()
 # Test if graphic element name is a valid identifier
 if not TestIdentifier(element_name):
 message_format = _("\"%s\" is not a valid identifier!")
 # Test that graphic element name isn't a keyword
 elif uppercase_element_name in IEC_KEYWORDS:
 message_format = _("\"%s\" is a keyword. It can't be used!")
 # Test that graphic element name isn't a POU name
 elif uppercase_element_name in self.Controller.GetProjectPouNames():
 message_format = _("\"%s\" pou already exists!")
 # Test that graphic element name isn't already used in POU by a variable
 # or another graphic element
 elif ((self.DefaultElementName is None or
 self.DefaultElementName.upper() != uppercase_element_name) and
 uppercase_element_name in self.Controller.\
 GetEditedElementVariables(self.TagName)):
 message_format = _("\"%s\" element for this pou already exists!")
 # If an error have been identify, show error message dialog
 if message_format is not None:
 self.ShowErrorMessage(message_format % element_name)
 # Test failed
 return False
 # Test succeed
 return True
 def ShowErrorMessage(self, message):
 """
 Show an error message dialog over this dialog
 @param message: Error message to display
 """
 dialog = wx.MessageDialog(self, message,
 _("Error"),
 wx.OK|wx.ICON_ERROR)
 dialog.ShowModal()
 dialog.Destroy()
 def OnOK(self, event):
 """
 Called when dialog OK button is pressed
 Need to be overridden by inherited classes to check that dialog values
 are valid
 @param event: wx.Event from OK button
 """
 # Close dialog
 self.EndModal(wx.ID_OK)
 def RefreshPreview(self):
 """
 Refresh preview panel of graphic element
 May be overridden by inherited classes
 """
 # Init preview panel paint device context
 dc = wx.ClientDC(self.Preview)
 dc.SetFont(self.Preview.GetFont())
 dc.Clear()
 # Return immediately if no graphic element defined
 if self.Element is None:
 return
 # Calculate block size according to graphic element min size due to its
 # parameters and graphic element min size defined
 min_width, min_height = self.GetMinElementSize()
 width = max(self.MinElementSize[0], min_width)
 height = max(self.MinElementSize[1], min_height)
 self.Element.SetSize(width, height)
 # Get element position and bounding box to center in preview
 posx, posy = self.Element.GetPosition()
 bbox = self.Element.GetBoundingBox()
 # Get Preview panel size
 client_size = self.Preview.GetClientSize()
 # If graphic element is too big to be displayed in preview panel,
 # calculate preview panel scale so that graphic element fit inside
 scale = (max(float(bbox.width) / client_size.width,
 float(bbox.height) / client_size.height) * 1.1
 if bbox.width * 1.1 > client_size.width or
 bbox.height * 1.1 > client_size.height
 else 1.0)
 dc.SetUserScale(1.0 / scale, 1.0 / scale)
 # Center graphic element in preview panel
 x = int(client_size.width * scale - bbox.width) / 2 + posx - bbox.x
 y = int(client_size.height * scale - bbox.height) / 2 + posy - bbox.y
 self.Element.SetPosition(x, y)
 # Draw graphic element
 self.Element.Draw(dc)
 def OnPaint(self, event):
 """
 Called when Preview panel need to be redraw
 @param event: wx.PaintEvent
 """
 self.RefreshPreview()
 event.Skip()

changeset 1730	64d8f52bc8c8
parent 1696	8043f32de7b8
child 1736	7e61baa047f0