HGKeeper

beremiz

Rewrite FBDVariableDialog

2013-06-11, Laurent Bessard

336d515096b1

Parents e77c95c4c7fc
Children d34ba528346b

Rewrite FBDVariableDialog

4 files changed, 268 insertions(+), 182 deletions(-)

+26 -24

dialogs/BlockPreviewDialog.py

+46 -25

dialogs/FBDBlockDialog.py

+182 -91

dialogs/FBDVariableDialog.py

+14 -42

editors/Viewer.py

~~--- a/dialogs/BlockPreviewDialog.py Tue Jun 11 09:03:35 2013 +0200~~

+++ b/dialogs/BlockPreviewDialog.py Tue Jun 11 12:37:50 2013 +0200

@@ -75,9 +75,11 @@

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

self.ButtonSizer.GetAffirmativeButton())

~~- self.Block = None # Graphic element to display in preview~~

~~- self.MinBlockSize = None # Graphic element minimal size~~

~~- self.DefaultBlockName = None # Graphic element name when opening dialog~~

+ 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

def __del__(self):

"""

@@ -86,12 +88,12 @@

# Remove reference to project controller

self.Controller = None

~~- def SetMinBlockSize(self, size):~~

+ def SetMinElementSize(self, size):

"""

Define minimal graphic element size

~~- @param size: wx.Size object containing minimal size~~

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

"""

~~- self.MinBlockSize = size~~

+ self.MinElementSize = size

def SetPreviewFont(self, font):

"""

@@ -100,39 +102,39 @@

"""

self.Preview.SetFont(font)

~~- def TestBlockName(self, block_name):~~

+ def TestElementName(self, element_name):

"""

Text displayed graphic element name

~~- @param block_name: 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_block_name = block_name.upper()~~

+ uppercase_element_name = element_name.upper()

# Test if graphic element name is a valid identifier

~~- if not TestIdentifier(block_name):~~

+ if not TestIdentifier(element_name):

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

# Test that graphic element name isn't a keyword

~~- elif uppercase_block_name in IEC_KEYWORDS:~~

+ 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_block_name in self.Controller.GetProjectPouNames():~~

+ 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.DefaultBlockName is None or~~

~~- self.DefaultBlockName.upper() != uppercase_block_name) and~~

~~- uppercase_block_name in self.Controller.GetEditedElementVariables(~~

~~- self.TagName)):~~

+ 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 % block_name)~~

+ self.ShowErrorMessage(message_format % element_name)

# Test failed

return False

@@ -171,15 +173,15 @@

dc.Clear()

# Return immediately if no graphic element defined

~~- if self.Block is None:~~

+ 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.Block.GetMinSize()~~

~~- width = max(self.MinBlockSize[0], min_width)~~

~~- height = max(self.MinBlockSize[1], min_height)~~

~~- self.Block.SetSize(width, height)~~

+ min_width, min_height = self.Element.GetMinSize()

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

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

+ self.Element.SetSize(width, height)

# Get Preview panel size

client_size = self.Preview.GetClientSize()

@@ -196,10 +198,10 @@

# Center graphic element in preview panel

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

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

~~- self.Block.SetPosition(x, y)~~

+ self.Element.SetPosition(x, y)

# Draw graphic element

~~- self.Block.Draw(dc)~~

+ self.Element.Draw(dc)

def OnPaint(self, event):

"""

~~--- a/dialogs/FBDBlockDialog.py Tue Jun 11 09:03:35 2013 +0200~~

+++ b/dialogs/FBDBlockDialog.py Tue Jun 11 12:37:50 2013 +0200

@@ -31,6 +31,13 @@

from BlockPreviewDialog import BlockPreviewDialog

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

+# Helpers

+#-------------------------------------------------------------------------------

+def GetBlockTypeDefaultNameModel(blocktype):

+ return re.compile("%s[0-9]+" % blocktype if blocktype is not None else ".*")

+#-------------------------------------------------------------------------------

# Set Block Parameters Dialog

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

@@ -136,11 +143,14 @@

right_gridsizer.AddWindow(self.PreviewLabel, flag=wx.GROW)

right_gridsizer.AddWindow(self.Preview, flag=wx.GROW)

+ # Add buttons sizer to sizers

main_sizer.AddSizer(self.ButtonSizer, border=20,

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

self.SetSizer(main_sizer)

+ # Dictionary containing correspondence between parameter exchanged and

+ # control to fill with parameter value

self.ParamsControl = {

"extension": self.Inputs,

"executionOrder": self.ExecutionOrder,

@@ -184,10 +194,11 @@

# Show error message if an error is detected

if message is not None:

~~- self.ShowMessage(message)~~

+ self.ShowErrorMessage(message)

# Test block name validity if necessary

~~- elif not name_enabled or self.TestBlockName(block_name):~~

+ elif not name_enabled or self.TestElementName(block_name):

+ # Call BlockPreviewDialog function

BlockPreviewDialog.OnOK(self, event)

def SetValues(self, values):

@@ -200,21 +211,16 @@

# Define regular expression for determine if block name is block

# default name

~~- default_name_model = re.compile(~~

~~- "%s[0-9]+" % blocktype if blocktype is not None else ".*")~~

~~- # Select block type in library panel~~

~~- if blocktype is not None:~~

~~- self.LibraryPanel.SelectTreeItem(blocktype,~~

~~- values.get("inputs", None))~~

+ default_name_model = GetBlockTypeDefaultNameModel(blocktype)

# For each parameters defined, set corresponding control value

for name, value in values.items():

+ # Parameter is block name

if name == "name":

~~- # Parameter is block name~~

if value != "":

~~- # Set default block name for testing~~

~~- self.DefaultBlockName = value~~

+ # Set default graphic element name for testing

+ self.DefaultElementName = value

# Test if block name is type default block name and save

# block name if not (name have been typed by user)

@@ -223,11 +229,17 @@

self.BlockName.ChangeValue(value)

+ # Set value of other controls

else:

control = self.ParamsControl.get(name, None)

if control is not None:

control.SetValue(value)

+ # Select block type in library panel

+ if blocktype is not None:

+ self.LibraryPanel.SelectTreeItem(blocktype,

+ values.get("inputs", None))

# Refresh preview panel

self.RefreshPreview()

@@ -239,7 +251,7 @@

values = self.LibraryPanel.GetSelectedBlock()

if self.BlockName.IsEnabled() and self.BlockName.GetValue() != "":

values["name"] = self.BlockName.GetValue()

~~- values["width"], values["height"] = self.Block.GetSize()~~

+ values["width"], values["height"] = self.Element.GetSize()

values.update({

name: control.GetValue()

for name, control in self.ParamsControl.iteritems()})

@@ -270,11 +282,22 @@

# current block name wasn't typed by user

if blocktype is not None and blocktype["type"] != "function":

self.BlockName.Enable(True)

~~- self.BlockName.ChangeValue(~~

~~- self.CurrentBlockName~~

~~- if self.CurrentBlockName is not None~~

~~- else self.Controller.GenerateNewName(~~

~~- self.TagName, None, values["type"]+"%d", 0))~~

+ if self.CurrentBlockName is None:

+ # Generate new block name according to block type, taking

+ # default element name if it was already a default name for this

+ # block type

+ default_name_model = GetBlockTypeDefaultNameModel(values["type"])

+ block_name = (

+ self.DefaultElementName

+ if (self.DefaultElementName is not None and

+ default_name_model.match(self.DefaultElementName))

+ else self.Controller.GenerateNewName(

+ self.TagName, None, values["type"]+"%d", 0))

+ else:

+ block_name = self.CurrentBlockName

+ self.BlockName.ChangeValue(block_name)

else:

self.BlockName.Enable(False)

self.BlockName.ChangeValue("")

@@ -328,13 +351,11 @@

# If a block type is selected in library panel

if values is not None:

~~- blockname = (self.BlockName.GetValue()~~

~~- if self.BlockName.IsEnabled()~~

~~- else "")~~

# Set graphic element displayed, creating a FBD block element

~~- self.Block = FBD_Block(self.Preview, values["type"],~~

~~- blockname,~~

+ self.Element = FBD_Block(self.Preview, values["type"],

+ (self.BlockName.GetValue()

+ if self.BlockName.IsEnabled()

+ else ""),

extension = self.Inputs.GetValue(),

inputs = values["inputs"],

executionControl = self.ExecutionControl.GetValue(),

@@ -342,7 +363,7 @@

# Reset graphic element displayed

else:

~~- self.Block = None~~

+ self.Element = None

# Call BlockPreviewDialog function

BlockPreviewDialog.RefreshPreview(self)

~~--- a/dialogs/FBDVariableDialog.py Tue Jun 11 09:03:35 2013 +0200~~

+++ b/dialogs/FBDVariableDialog.py Tue Jun 11 12:37:50 2013 +0200

@@ -24,12 +24,16 @@

import wx

-from graphics import *

+from graphics.GraphicCommons import INPUT, INOUT, OUTPUT

+from graphics.FBD_Objects import FBD_Variable

+from BlockPreviewDialog import BlockPreviewDialog

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

# Helpers

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

+# Dictionaries containing correspondence between variable block class and string

+# to be shown in Class combo box in both sense

VARIABLE_CLASSES_DICT = {INPUT : _("Input"),

INOUT : _("InOut"),

OUTPUT : _("Output")}

@@ -37,199 +41,286 @@

[(value, key) for key, value in VARIABLE_CLASSES_DICT.iteritems()])

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

~~-# Create New Variable Dialog~~

+# Set Variable Parameters Dialog

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

~~-class FBDVariableDialog(wx.Dialog):~~

+"""

+Class that implements a dialog for defining parameters of a FBD variable graphic

+element

+"""

+class FBDVariableDialog(BlockPreviewDialog):

~~- def __init__(self, parent, controller, transition = ""):~~

~~- wx.Dialog.__init__(self, parent,~~

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

+ """

+ Constructor

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

+ @param controller: Reference to project controller

+ @param tagname: Tagname of project POU edited

+ """

+ BlockPreviewDialog.__init__(self, parent, controller, tagname,

size=wx.Size(400, 380), title=_('Variable Properties'))

+ # Create dialog main sizer

main_sizer = wx.FlexGridSizer(cols=1, hgap=0, rows=4, vgap=10)

main_sizer.AddGrowableCol(0)

main_sizer.AddGrowableRow(2)

+ # Create a sizer for dividing FBD variable parameters in two columns

column_sizer = wx.BoxSizer(wx.HORIZONTAL)

main_sizer.AddSizer(column_sizer, border=20,

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

+ # Create a sizer for left column

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

left_gridsizer.AddGrowableCol(0)

column_sizer.AddSizer(left_gridsizer, 1, border=5,

flag=wx.GROW|wx.RIGHT)

+ # Create label for variable class

class_label = wx.StaticText(self, label=_('Class:'))

left_gridsizer.AddWindow(class_label, flag=wx.GROW)

+ # Create a combo box for defining variable class

self.Class = wx.ComboBox(self, style=wx.CB_READONLY)

self.Bind(wx.EVT_COMBOBOX, self.OnClassChanged, self.Class)

left_gridsizer.AddWindow(self.Class, flag=wx.GROW)

~~- execution_order_label = wx.StaticText(self, label=_('Execution Order:'))~~

+ # Create label for variable execution order

+ execution_order_label = wx.StaticText(self,

+ label=_('Execution Order:'))

left_gridsizer.AddWindow(execution_order_label, flag=wx.GROW)

+ # Create spin control for defining variable execution order

self.ExecutionOrder = wx.SpinCtrl(self, min=0, style=wx.SP_ARROW_KEYS)

~~- self.Bind(wx.EVT_SPINCTRL, self.OnExecutionOrderChanged, self.ExecutionOrder)~~

+ self.Bind(wx.EVT_SPINCTRL, self.OnExecutionOrderChanged,

+ self.ExecutionOrder)

left_gridsizer.AddWindow(self.ExecutionOrder, flag=wx.GROW)

+ # Create a sizer for right column

right_gridsizer = wx.FlexGridSizer(cols=1, hgap=0, rows=3, vgap=0)

right_gridsizer.AddGrowableCol(0)

right_gridsizer.AddGrowableRow(2)

column_sizer.AddSizer(right_gridsizer, 1, border=5,

flag=wx.GROW|wx.LEFT)

+ # Create label for variable expression

name_label = wx.StaticText(self, label=_('Expression:'))

right_gridsizer.AddWindow(name_label, border=5, flag=wx.GROW|wx.BOTTOM)

+ # Create text control for defining variable expression

self.Expression = wx.TextCtrl(self)

self.Bind(wx.EVT_TEXT, self.OnExpressionChanged, self.Expression)

right_gridsizer.AddWindow(self.Expression, flag=wx.GROW)

+ # Create a list box to selected variable expression in the list of

+ # variables defined in POU

self.VariableName = wx.ListBox(self, size=wx.Size(0, 120),

style=wx.LB_SINGLE|wx.LB_SORT)

self.Bind(wx.EVT_LISTBOX, self.OnNameChanged, self.VariableName)

right_gridsizer.AddWindow(self.VariableName, flag=wx.GROW)

~~- preview_label = wx.StaticText(self, label=_('Preview:'))~~

~~- main_sizer.AddWindow(preview_label, border=20,~~

+ # Add preview panel and associated label to sizers

+ main_sizer.AddWindow(self.PreviewLabel, border=20,

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

~~- self.Preview = wx.Panel(self,~~

~~- style=wx.TAB_TRAVERSAL|wx.SIMPLE_BORDER)~~

~~- self.Preview.SetBackgroundColour(wx.Colour(255,255,255))~~

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

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

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

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

main_sizer.AddWindow(self.Preview, border=20,

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

~~- button_sizer = self.CreateButtonSizer(wx.OK|wx.CANCEL|wx.CENTRE)~~

~~- self.Bind(wx.EVT_BUTTON, self.OnOK, button_sizer.GetAffirmativeButton())~~

~~- main_sizer.AddSizer(button_sizer, border=20,~~

+ # Add buttons sizer to sizers

+ main_sizer.AddSizer(self.ButtonSizer, border=20,

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

self.SetSizer(main_sizer)

~~- self.Transition = transition~~

~~- self.Variable = None~~

~~- self.VarList = []~~

~~- self.MinVariableSize = None~~

+ # Set options that can be selected in class combo box

for choice in VARIABLE_CLASSES_DICT.itervalues():

self.Class.Append(choice)

self.Class.SetStringSelection(VARIABLE_CLASSES_DICT[INPUT])

+ # Get list of variables defined in POU

+ self.VarList = {

+ 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.VarList[

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

+ ("Output", returntype)

+ # Add POU name if POU is a transition

+ words = tagname.split("::")

+ if words[0] == "T":

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

+ # Refresh values in name list box

self.RefreshNameList()

+ # Class combo box is default control having keyboard focus

self.Class.SetFocus()

~~- def SetPreviewFont(self, font):~~

~~- self.Preview.SetFont(font)~~

def RefreshNameList(self):

~~- selected = self.Expression.GetValue()~~

~~- var_class = VARIABLE_CLASSES_DICT_REVERSE[self.Class.GetStringSelection()]~~

+ """

+ Called to refresh names in name list box

+ """

+ # Get variable class to select POU variable applicable

+ var_class = VARIABLE_CLASSES_DICT_REVERSE[

+ self.Class.GetStringSelection()]

+ # Refresh names in name list box by selecting variables in POU variables

+ # list that can be applied to variable class

self.VariableName.Clear()

~~- for name, var_type, value_type in self.VarList:~~

+ for name, (var_type, value_type) in self.VarList.iteritems():

if var_type != "Input" or var_class == INPUT:

self.VariableName.Append(name)

~~- if selected != "" and self.VariableName.FindString(selected) != wx.NOT_FOUND:~~

+ # Get variable expression and select corresponding value in name list

+ # box if it exists

+ selected = self.Expression.GetValue()

+ if (selected != "" and

+ self.VariableName.FindString(selected) != wx.NOT_FOUND):

self.VariableName.SetStringSelection(selected)

else:

self.VariableName.SetSelection(wx.NOT_FOUND)

+ # Disable name list box if no name present inside

self.VariableName.Enable(self.VariableName.GetCount() > 0)

~~- def SetMinVariableSize(self, size):~~

~~- self.MinVariableSize = size~~

~~- def SetVariables(self, vars):~~

~~- self.VarList = vars~~

~~- self.RefreshNameList()~~

def SetValues(self, values):

~~- value_type = values.get("type", None)~~

~~- value_name = values.get("name", None)~~

~~- if value_type:~~

~~- self.Class.SetStringSelection(VARIABLE_CLASSES_DICT[value_type])~~

+ """

+ Set default variable parameters

+ @param values: Variable parameters values

+ """

+ # Get class parameter value

+ var_class = values.get("class", None)

+ if var_class is not None:

+ # Set class selected in class combo box

+ self.Class.SetStringSelection(VARIABLE_CLASSES_DICT[var_class])

+ # Refresh names in name list box according to var class

self.RefreshNameList()

~~- if value_name:~~

~~- self.Expression.ChangeValue(value_name)~~

~~- if self.VariableName.FindString(value_name) != wx.NOT_FOUND:~~

~~- self.VariableName.SetStringSelection(value_name)~~

~~- else:~~

~~- self.VariableName.SetSelection(wx.NOT_FOUND)~~

~~- if "executionOrder" in values:~~

~~- self.ExecutionOrder.SetValue(values["executionOrder"])~~

+ # For each parameters defined, set corresponding control value

+ for name, value in values.items():

+ # Parameter is variable expression

+ if name == "expression":

+ # Set expression text control value

+ self.Expression.ChangeValue(value)

+ # Select corresponding text in name list box if it exists

+ if self.VariableName.FindString(value) != wx.NOT_FOUND:

+ self.VariableName.SetStringSelection(value)

+ else:

+ self.VariableName.SetSelection(wx.NOT_FOUND)

+ # Parameter is variable execution order

+ elif name == "executionOrder":

+ self.ExecutionOrder.SetValue(value)

+ # Refresh preview panel

self.RefreshPreview()

def GetValues(self):

~~- values = {}~~

~~- values["type"] = VARIABLE_CLASSES_DICT_REVERSE[self.Class.GetStringSelection()]~~

~~- values["name"] = self.Expression.GetValue()~~

~~- values["value_type"] = None~~

~~- for var_name, var_type, value_type in self.VarList:~~

~~- if var_name == values["name"]:~~

~~- values["value_type"] = value_type~~

~~- values["width"], values["height"] = self.Variable.GetSize()~~

~~- values["executionOrder"] = self.ExecutionOrder.GetValue()~~

+ """

+ Return block parameters defined in dialog

+ @return: {parameter_name: parameter_value,...}

+ """

+ expression = self.Expression.GetValue()

+ values = {

+ "class": VARIABLE_CLASSES_DICT_REVERSE[

+ self.Class.GetStringSelection()],

+ "expression": expression,

+ "var_type": self.VarList.get(expression, (None, None))[1],

+ "executionOrder": self.ExecutionOrder.GetValue()}

+ values["width"], values["height"] = self.Element.GetSize()

return values

def OnOK(self, event):

+ """

+ Called when dialog OK button is pressed

+ Test if parameters defined are valid

+ @param event: wx.Event from OK button

+ """

message = None

+ # Test that an expression have been selected or typed by user

value = self.Expression.GetValue()

if value == "":

message = _("At least a variable or an expression must be selected!")

+ # Show error message if an error is detected

if message is not None:

~~- message = wx.MessageDialog(self, message, _("Error"), wx.OK|wx.ICON_ERROR)~~

~~- message.ShowModal()~~

~~- message.Destroy()~~

+ self.ShowErrorMessage(message)

else:

~~- self.EndModal(wx.ID_OK)~~

+ # Call BlockPreviewDialog function

+ BlockPreviewDialog.OnOK(self, event)

def OnClassChanged(self, event):

+ """

+ Called when variable class value changed

+ @param event: wx.ComboBoxEvent

+ """

+ # Refresh name list box values

self.RefreshNameList()

self.RefreshPreview()

event.Skip()

def OnNameChanged(self, event):

~~- self.Expression.ChangeValue(~~

~~- self.VariableName.GetStringSelection())~~

+ """

+ Called when name selected in name list box changed

+ @param event: wx.ListBoxEvent

+ """

+ # Change expression test control value to the value selected in name

+ # list box if value selected is valid

+ if self.VariableName.GetSelection() != wx.NOT_FOUND:

+ self.Expression.ChangeValue(self.VariableName.GetStringSelection())

self.RefreshPreview()

event.Skip()

def OnExpressionChanged(self, event):

~~- expression = self.Expression.GetValue()~~

+ """

+ Called when expression text control is changed by user

+ @param event: wx.ListBoxEvent

+ """

+ # Select the corresponding value in name list box if it exists

self.VariableName.SetSelection(

~~- self.VariableName.FindString(expression))~~

+ self.VariableName.FindString(self.Expression.GetValue()))

self.RefreshPreview()

event.Skip()

def OnExecutionOrderChanged(self, event):

+ """

+ Called when block execution control value changed

+ @param event: wx.SpinEvent

+ """

self.RefreshPreview()

event.Skip()

def RefreshPreview(self):

~~- dc = wx.ClientDC(self.Preview)~~

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

~~- dc.Clear()~~

+ """

+ Refresh preview panel of graphic element

+ Override BlockPreviewDialog function

+ """

+ # Get expression value to put in FBD variable element

name = self.Expression.GetValue()

~~- type = ""~~

~~- for var_name, var_type, value_type in self.VarList:~~

~~- if var_name == name:~~

~~- type = value_type~~

~~- classtype = VARIABLE_CLASSES_DICT_REVERSE[self.Class.GetStringSelection()]~~

~~- self.Variable = FBD_Variable(self.Preview, classtype, name, type, executionOrder = self.ExecutionOrder.GetValue())~~

~~- width, height = self.MinVariableSize~~

~~- min_width, min_height = self.Variable.GetMinSize()~~

~~- width, height = max(min_width, width), max(min_height, height)~~

~~- self.Variable.SetSize(width, height)~~

~~- clientsize = self.Preview.GetClientSize()~~

~~- x = (clientsize.width - width) / 2~~

~~- y = (clientsize.height - height) / 2~~

~~- self.Variable.SetPosition(x, y)~~

~~- self.Variable.Draw(dc)~~

~~- def OnPaint(self, event):~~

~~- self.RefreshPreview()~~

~~- event.Skip()~~

+ # Set graphic element displayed, creating a FBD variable element

+ self.Element = FBD_Variable(self.Preview,

+ VARIABLE_CLASSES_DICT_REVERSE[

+ self.Class.GetStringSelection()],

+ name,

+ self.VarList.get(name, ("", ""))[1],

+ executionOrder = self.ExecutionOrder.GetValue())

+ # Call BlockPreviewDialog function

+ BlockPreviewDialog.RefreshPreview(self)

\ No newline at end of file

~~--- a/editors/Viewer.py Tue Jun 11 09:03:35 2013 +0200~~

+++ b/editors/Viewer.py Tue Jun 11 12:37:50 2013 +0200

@@ -2199,7 +2199,7 @@

def AddNewBlock(self, bbox):

dialog = FBDBlockDialog(self.ParentWindow, self.Controler, self.TagName)

dialog.SetPreviewFont(self.GetFont())

~~- dialog.SetMinBlockSize((bbox.width, bbox.height))~~

+ dialog.SetMinElementSize((bbox.width, bbox.height))

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

id = self.GetNewId()

values = dialog.GetValues()

@@ -2222,31 +2222,17 @@

dialog.Destroy()

def AddNewVariable(self, bbox):

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

~~- if words[0] == "T":~~

~~- dialog = FBDVariableDialog(self.ParentWindow, self.Controler, words[2])~~

~~- else:~~

~~- dialog = FBDVariableDialog(self.ParentWindow, self.Controler)~~

+ dialog = FBDVariableDialog(self.ParentWindow, self.Controler, self.TagName)

dialog.SetPreviewFont(self.GetFont())

~~- dialog.SetMinVariableSize((bbox.width, bbox.height))~~

~~- varlist = []~~

~~- vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)~~

~~- if vars:~~

~~- for var in vars:~~

~~- if var["Edit"]:~~

~~- varlist.append((var["Name"], var["Class"], var["Type"]))~~

~~- returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)~~

~~- if returntype:~~

~~- varlist.append((self.Controler.GetEditedElementName(self.TagName), "Output", returntype))~~

~~- dialog.SetVariables(varlist)~~

+ dialog.SetMinElementSize((bbox.width, bbox.height))

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

id = self.GetNewId()

values = dialog.GetValues()

~~- variable = FBD_Variable(self, values["type"], values["name"], values["value_type"], id)~~

+ variable = FBD_Variable(self, values["class"], values["expression"], values["vr_type"], id)

variable.SetPosition(bbox.x, bbox.y)

variable.SetSize(*self.GetScaledSize(values["width"], values["height"]))

self.AddBlock(variable)

~~- self.Controler.AddEditedElementVariable(self.TagName, id, values["type"])~~

+ self.Controler.AddEditedElementVariable(self.TagName, id, values["class"])

self.RefreshVariableModel(variable)

self.RefreshBuffer()

self.RefreshScrollBars()

@@ -2500,7 +2486,7 @@

def EditBlockContent(self, block):

dialog = FBDBlockDialog(self.ParentWindow, self.Controler, self.TagName)

dialog.SetPreviewFont(self.GetFont())

~~- dialog.SetMinBlockSize(block.GetSize())~~

+ dialog.SetMinElementSize(block.GetSize())

old_values = {"name" : block.GetName(),

"type" : block.GetType(),

"extension" : block.GetExtension(),

@@ -2532,38 +2518,24 @@

dialog.Destroy()

def EditVariableContent(self, variable):

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

~~- if words[0] == "T":~~

~~- dialog = FBDVariableDialog(self.ParentWindow, self.Controler, words[2])~~

~~- else:~~

~~- dialog = FBDVariableDialog(self.ParentWindow, self.Controler)~~

+ dialog = FBDVariableDialog(self.ParentWindow, self.Controler, self.TagName)

dialog.SetPreviewFont(self.GetFont())

~~- dialog.SetMinVariableSize(variable.GetSize())~~

~~- varlist = []~~

~~- vars = self.Controler.GetEditedElementInterfaceVars(self.TagName, self.Debug)~~

~~- if vars:~~

~~- for var in vars:~~

~~- if var["Edit"]:~~

~~- varlist.append((var["Name"], var["Class"], var["Type"]))~~

~~- returntype = self.Controler.GetEditedElementInterfaceReturnType(self.TagName, self.Debug)~~

~~- if returntype:~~

~~- varlist.append((self.Controler.GetEditedElementName(self.TagName), "Output", returntype))~~

~~- dialog.SetVariables(varlist)~~

~~- old_values = {"name" : variable.GetName(), "type" : variable.GetType(),~~

~~- "executionOrder" : variable.GetExecutionOrder()}~~

+ dialog.SetMinElementSize(variable.GetSize())

+ old_values = {"expression" : variable.GetName(), "class" : variable.GetType(),

+ "executionOrder" : variable.GetExecutionOrder()}

dialog.SetValues(old_values)

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

new_values = dialog.GetValues()

rect = variable.GetRedrawRect(1, 1)

~~- variable.SetName(new_values["name"])~~

~~- variable.SetType(new_values["type"], new_values["value_type"])~~

+ variable.SetName(new_values["expression"])

+ variable.SetType(new_values["class"], new_values["var_type"])

variable.SetSize(*self.GetScaledSize(new_values["width"], new_values["height"]))

variable.SetExecutionOrder(new_values["executionOrder"])

rect = rect.Union(variable.GetRedrawRect())

~~- if old_values["type"] != new_values["type"]:~~

+ if old_values["class"] != new_values["class"]:

id = variable.GetId()

self.Controler.RemoveEditedElementInstance(self.TagName, id)

~~- self.Controler.AddEditedElementVariable(self.TagName, id, new_values["type"])~~

+ self.Controler.AddEditedElementVariable(self.TagName, id, new_values["class"])

self.RefreshVariableModel(variable)

self.RefreshBuffer()

if old_values["executionOrder"] != new_values["executionOrder"]: