import __builtin__

import util.paths as paths

class BeremizIDELauncher:

def __init__(self):

self.updateinfo_url = None

beremiz_dir = paths.AbsDir(__file__)

def Bpath(*args):

return os.path.join(beremiz_dir,*args)

MainThread = currentThread().ident

REFRESH_PERIOD = 0.1

from time import time as gettime

class LogPseudoFile:

""" Base class for file like objects to facilitate StdOut for the Shell."""

def __init__(self, output, risecall):

EncodeFileSystemPath, DecodeFileSystemPath

from util.BitmapLibrary import GetBitmap

class Beremiz(IDEFrame):

def _init_utils(self):

Max_Traceback_List_Size = 20

def Display_Exception_Dialog(e_type, e_value, e_tb, bug_report_path):

trcbck_lst = []

for i,line in enumerate(traceback.extract_tb(e_tb)):

return res

def get_last_traceback(tb):

while tb.tb_next:

tb = tb.tb_next

ignored_exceptions = [] # a problem with a line in a module is only reported once per session

def AddExceptHook(path, app_version='[No version]'):#, ignored_exceptions=[]):

def save_bug_report(e_type, e_value, e_traceback, bug_report_path,date):

import getopt

from threading import Thread

def usage():

print """

Usage of Beremiz PLC execution service :\n

if __name__ == '__main__':

__builtin__.__dict__['_'] = lambda x: x

def Bpath(*args):

return os.path.join(beremiz_dir,*args)

def SetupI18n():

# Import module for internationalization

import gettext

if not os.path.isdir(WorkingDir):

os.mkdir(WorkingDir)

def default_evaluator(tocall, *args, **kwargs):

try:

res=(tocall(*args,**kwargs), None)

res=(None, sys.exc_info())

return res

class Server():

def __init__(self, servicename, ip_addr, port,

workdir, argv, autostart=False,

# Exception hooks s

import threading

import traceback

def LogException(*exp):

if pyroserver.plcobj is not None:

pyroserver.plcobj.LogMessage(0,'\n'.join(traceback.format_exception(*exp)))

traceback.print_exception(*exp)

sys.excepthook = LogException

def installThreadExcepthook():

init_old = threading.Thread.__init__

def init(self, *args, **kwargs):

SECTION_TAG_ELEMENT = "<xsd:element name=\"%s\" type=\"CodeText\"/>"

class CodeFile:

CODEFILE_NAME = "CodeFile"

NameTypeSeparator = '@'

XSDSchemaErrorMessage = _("{a1} XML file doesn't follow XSD schema at line {a2}:\n{a3}")

class ConfigTreeNode:

"""

This class is the one that define confnodes.

import base64

def EncodeFileSystemPath(path, use_base64=True):

path = path.encode(sys.getfilesystemencoding())

if use_base64:

return base64.encodestring(path)

return path

def DecodeFileSystemPath(path, is_base64=True):

if is_base64:

path = base64.decodestring(path)

return unicode(path, sys.getfilesystemencoding())

def AppendMenu(parent, help, id, kind, text):

if wx.VERSION >= (2, 6, 0):

parent.Append(help=help, id=id, kind=kind, text=text)

else:

POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

] = range(10)

def GetShortcutKeyCallbackFunction(viewer_function):

def ShortcutKeyFunction(self, event):

control = self.FindFocus()

control.ProcessEvent(event)

return ShortcutKeyFunction

def GetDeleteElementFunction(remove_function, parent_type=None, check_function=None):

def DeleteElementFunction(self, selected):

name = self.ProjectTree.GetItemText(selected)

TAB_BORDER = 7

NOTEBOOK_BORDER = 2

def SimplifyTabLayout(tabs, rect):

for tab in tabs:

if tab["pos"][0] == rect.x:

return True

return False

def ComputeTabsLayout(tabs, rect):

if len(tabs) == 0:

return tabs

UNEDITABLE_NAMES_DICT = dict([(_(name), name) for name in UNEDITABLE_NAMES])

class IDEFrame(wx.Frame):

# Compatibility function for wx versions < 2.6

UPPER_DIV = lambda x, y: (x / y) + {True : 0, False : 1}[(x % y) == 0]

class GraphicPrintout(wx.Printout):

def __init__(self, viewer, page_size, margins, preview = False):

wx.Printout.__init__(self)

import util.paths as paths

from POULibrary import POULibrary

class NativeLibrary(POULibrary):

def GetLibraryPath(self):

return paths.AbsNeighbourFile(__file__, "NativeLib.xml")

ScriptDirectory = paths.AbsDir(__file__)

def GetUneditableNames():

_ = lambda x:x

return [_("User-defined POUs"), _("Functions"), _("Function Blocks"),

# Helper object for loading library in xslt stylesheets

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

class LibraryResolver(etree.Resolver):

def __init__(self, controller, debug=False):

_StringValue = lambda x: x

_BoolValue = lambda x: x in ["true", "0"]

def _translate_args(translations, args):

return [translate(arg[0]) if len(arg) > 0 else None

for translate, arg in

# Helpers object for generating pou var list

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

class _VariableInfos(object):

__slots__ = ["Name", "Class", "Option", "Location", "InitialValue",

"Edit", "Documentation", "Type", "Tree", "Number"]

def copy(self):

return _VariableInfos(*[getattr(self, attr) for attr in self.__slots__])

class VariablesInfosFactory:

def __init__(self, variables):

# Helpers object for generating pou variable instance list

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

def class_extraction(value):

class_type = {

"configuration": ITEM_CONFIGURATION,

return None

class _VariablesTreeItemInfos(object):

__slots__ = ["name", "var_class", "type", "edit", "debug", "variables"]

def __init__(self, *args):

def copy(self):

return _VariableTreeItem(*[getattr(self, attr) for attr in self.__slots__])

class VariablesTreeInfosFactory:

def __init__(self):

# Helpers object for generating instances path list

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

class InstancesPathFactory:

def __init__(self, instances):

# Helpers object for generating instance tagname

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

class InstanceTagName:

def __init__(self, controller):

_ConnectionLinkInfos = namedtuple("ConnectionLinkInfos",

["refLocalId", "formalParameter", "points"])

class _ActionInfos(object):

__slots__ = ["qualifier", "type", "value", "duration", "indicator"]

def __init__(self, *args):

def copy(self):

return _ActionInfos(*[getattr(self, attr) for attr in self.__slots__])

class BlockInstanceFactory:

def __init__(self, block_instances):

# Length of the buffer

UNDO_BUFFER_LENGTH = 20

class UndoBuffer:

def __init__(self, currentstate, issaved = False):

self.Buffer = []

self.CurrentIndex = -1

self.MinIndex = -1

else:

self.LastSave = -1

def Buffering(self, currentstate):

self.CurrentIndex = (self.CurrentIndex + 1) % UNDO_BUFFER_LENGTH

self.Buffer[self.CurrentIndex] = currentstate

# Actualising buffer limits

self.MinIndex = (self.MinIndex + 1) % UNDO_BUFFER_LENGTH

self.MinIndex = max(self.MinIndex, 0)

def Current(self):

return self.Buffer[self.CurrentIndex]

# Change current state to previous in buffer and return new current state

# Controler for PLCOpenEditor

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

class PLCControler:

# Create a new PLCControler

def __init__(self):

"VAR_INOUT": "var_inout",

}

def ReIndentText(text, nb_spaces):

compute = ""

lines = text.splitlines()

if len(lines) > 0:

compute += "\n"

return compute

def SortInstances(a, b):

ax, ay = int(a.getx()), int(a.gety())

bx, by = int(b.getx()), int(b.gety())

else:

return cmp(ay, by)

def JoinList(separator, mylist):

if len(mylist) > 0 :

return reduce(lambda x, y: x + separator + y, mylist)

else :

TransitionObjClass = PLCOpenParser.GetElementClass("transition", "transitions")

ActionObjClass = PLCOpenParser.GetElementClass("action", "actions")

class PouProgramGenerator:

# Create a new POU program generator

program += [("END_%s\n\n" % self.Type, ())]

return program

def GenerateCurrentProgram(controler, project, errors, warnings):

generator = ProgramGenerator(controler, project, errors, warnings)

generator.GenerateProgram()

[ID_PLCOPENEDITORFILEMENUGENERATE,

] = [wx.NewId() for _init_coll_FileMenu_Items in range(1)]

class PLCOpenEditor(IDEFrame):

# Compatibility function for wx versions < 2.6

Max_Traceback_List_Size = 20

def Display_Exception_Dialog(e_type,e_value,e_tb):

trcbck_lst = []

for i,line in enumerate(traceback.extract_tb(e_tb)):

return res

def Display_Error_Dialog(e_value):

message = wx.MessageDialog(None, str(e_value), _("Error"), wx.OK|wx.ICON_ERROR)

message.ShowModal()

message.Destroy()

def get_last_traceback(tb):

while tb.tb_next:

tb = tb.tb_next

ignored_exceptions = [] # a problem with a line in a module is only reported once per session

def AddExceptHook(path, app_version='[No version]'):#, ignored_exceptions=[]):

def handle_exception(e_type, e_value, e_traceback):

from weakref import ref

class POULibrary:

def __init__(self, CTR, LibName, TypeStack):

from PLCControler import PLCControler

ITEM_CONFNODE = 25

def ExtractChildrenTypesFromCatalog(catalog):

children_types = []

for n,d,h,c in catalog:

children_types.append((n, GetClassImporter(c), d))

return children_types

def ExtractMenuItemsFromCatalog(catalog):

menu_items = []

for n,d,h,c in catalog:

menu_items.append((n, d, h, children))

return menu_items

def GetAddMenuItems():

return ExtractMenuItemsFromCatalog(features.catalog)

class Iec2CSettings():

def __init__(self):

self.iec2c = None

iec2c_cfg = Iec2CSettings()

class ProjectController(ConfigTreeNode, PLCControler):

"""

This class define Root object of the confnode tree.

from controls.CustomStyledTextCtrl import faces

from editors.CodeFileEditor import CodeFileEditor, CodeEditor

class CppEditor(CodeEditor):

KEYWORDS = ["asm", "auto", "bool", "break", "case", "catch", "char", "class",

# CFileEditor Main Frame Class

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

class CFileEditor(CodeFileEditor):

CONFNODEEDITOR_TABS = [

from CFileEditor import CFileEditor

from CodeFileTreeNode import CodeFile

class CFile(CodeFile):

XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

ID_NETWORKEDITORADDMENUMAPVARIABLE, ID_NETWORKEDITORADDMENUUSERTYPE,

] = [wx.NewId() for _init_coll_AddMenu_Items in range(6)]

class NetworkEditor(ConfTreeNodeEditor, NetworkEditorTemplate):

ID = ID_NETWORKEDITOR

ID_SLAVEEDITORADDMENUMAPVARIABLE, ID_SLAVEEDITORADDMENUUSERTYPE,

] = [wx.NewId() for _init_coll_AddMenu_Items in range(6)]

class SlaveEditor(ConfTreeNodeEditor, NodeEditorTemplate):

CONFNODEEDITOR_TABS = [

self.ParentWindow.RefreshEditMenu()

self.ParentWindow.RefreshPageTitles()

class MasterViewer(SlaveEditor):

SHOW_BASE_PARAMS = False

SHOW_PARAMS = False

# Location Tree Helper

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

def GetSlaveLocationTree(slave_node, current_location, name):

entries = []

for index, subindex, size, entry_name in slave_node.GetMapVariableList():

# SLAVE

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

class _SlaveCTN(NodeManager):

XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

# MASTER

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

class MiniNodeManager(NodeManager):

def __init__(self, parent, filepath, fullname):

ConfNodeMethods = []

class _NodeManager(NodeManager):

def __init__(self, parent, *args, **kwargs):

def GetCurrentNodeID(self):

return self.Parent.CanFestivalNode.getNodeId()

class _NodeListCTN(NodeList):

XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

def GetBufferState(self):

return self.Manager.GetCurrentBufferState()

class RootClass:

XSD = """<?xml version="1.0" encoding="ISO-8859-1" ?>

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">

# Specific exception for PDO mapping errors

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

class PDOmappingException(Exception):

pass

dcfdata += [LE_to_BE(idx, 2) + LE_to_BE(0x01, 1) + LE_to_BE(0x04, 4) + LE_to_BE(cobid, 4)]

return "".join(dcfdata), len(dcfdata)

class ConciseDCFGenerator:

def __init__(self, nodelist, nodename):

# Add variable to pointed variables

self.PointedVariables[(mapvariableidx, nbsubentries)] = "%s_%s" % (indexname, subindexname)

def GenerateConciseDCF(locations, current_location, nodelist, sync_TPDOs, nodename):

"""

Fills a CanFestival network editor model, with DCF with requested PDO mappings.

pointers.update(LocalODPointers(locations, current_location, masternode))

return masternode,pointers

def LocalODPointers(locations, current_location, slave):

IECLocations = {}

pointers = {}

# for connectors that do not support DNS-SD, this attribute can be omitted

# or set to an empty list.

def PYRO_connector_factory(uri, confnodesroot):

"""

This returns the connector to Pyro style PLCobject

_WampConnection = None

_WampSessionEvent = Event()

class WampSession(wamp.ApplicationSession):

def onJoin(self, details):

global _WampSession, _WampSessionEvent

"GetPLCstatus" : ("Broken",None),

"RemoteExec" : (-1, "RemoteExec script failed!")}

def WAMP_connector_factory(uri, confnodesroot):

"""

WAMP://127.0.0.1:12345/path#realm#ID

import wx

import wx.gizmos

class CustomEditableListBox(wx.gizmos.EditableListBox):

def __init__(self, *args, **kwargs):

import wx

import wx.grid

class CustomGrid(wx.grid.Grid):

def __init__(self, *args, **kwargs):

wx.WXK_NUMPAD_PAGEDOWN,

wx.WXK_NUMPAD_END]

def GetCursorPos(old, new):

if old == "":

return 0

else:

return None

class CustomStyledTextCtrl(wx.stc.StyledTextCtrl):

def __init__(self, *args, **kwargs):

else:

ROW_HEIGHT = 28

class CustomTable(wx.grid.PyGridTableBase):

"""

# Custom ToolTip

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

class CustomToolTip(wx.PopupWindow):

def __init__(self, parent, tip, restricted=True):

"""

# Customize CustomTreeItem for adding icon on item left

CT.GenericTreeItem._ExtraImage = None

def SetExtraImage(self, image):

self._type = (1 if image is not None else 0)

self._ExtraImage = image

CT.GenericTreeItem.SetExtraImage = SetExtraImage

_DefaultGetCurrentCheckedImage = CT.GenericTreeItem.GetCurrentCheckedImage

def GetCurrentCheckedImage(self):

if self._ExtraImage is not None:

return self._ExtraImage

return _DefaultGetCurrentCheckedImage(self)

CT.GenericTreeItem.GetCurrentCheckedImage = GetCurrentCheckedImage

class CustomTree(CT.CustomTreeCtrl):

def __init__(self, *args, **kwargs):

# Debug Variable Graphic Viewer Helpers

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

def merge_ranges(ranges):

"""

Merge variables data range in a list to return a range of minimal min range

# Debug Variable Graphic Viewer Drop Target

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

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

def __init__(self, parent, window):

"""

# Debug Variable Graphic Viewer Class

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

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

def __init__(self, parent, window, items, graph_type):

"""

# Debug Variable Item Class

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

class DebugVariableItem(DebugDataConsumer):

def __init__(self, parent, variable, store_data=False):

"""

# Scrollbar increment in pixel

SCROLLBAR_UNIT = 10

def compute_mask(x, y):

return [(xp if xp == yp else "*")

for xp, yp in zip(x, y)]

def NextTick(variables):

next_tick = None

for item, data in variables:

# Debug Variable Graphic Panel Drop Target

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

class DebugVariableDropTarget(wx.TextDropTarget):

def __init__(self, window):

"""

# Debug Variable Graphic Panel Class

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

class DebugVariablePanel(wx.Panel, DebugViewer):

def __init__(self, parent, producer, window):

"""

# Debug Variable Text Viewer Drop Target

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

class DebugVariableTextDropTarget(wx.TextDropTarget):

def __init__(self, parent, window):

"""

# Debug Variable Text Viewer Class

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

class DebugVariableTextViewer(DebugVariableViewer, wx.Panel):

def __init__(self, parent, window, items=[]):

"""

# Base Debug Variable Viewer Class

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

class DebugVariableViewer:

def __init__(self, window, items=[]):

"""

# Custom button for Graphic Viewer Class

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

class GraphButton():

def __init__(self, x, y, bitmap, callback):

"""

from dialogs.DurationEditorDialog import DurationEditorDialog

class DurationCellControl(wx.PyControl):

'''

def SetFocus(self):

self.Duration.SetFocus()

class DurationCellEditor(wx.grid.PyGridCellEditor):

'''

Grid cell editor that uses DurationCellControl to display an edit button.

def __init__(self, widget, pos, horizontalalignment=ESB_ALIGN_CENTER_HORIZONTAL, verticalalignment=ESB_ALIGN_CENTER_VERTICAL):

self.__dict__.update( locals() )

class EnhancedStatusBar(wx.StatusBar):

def __init__(self, parent, id=wx.ID_ANY, style=wx.ST_SIZEGRIP,

DRIVE, FOLDER, FILE = range(3)

def sort_folder(x, y):

if x[1] == y[1]:

return cmp(x[0], y[0])

else:

return 1

def splitpath(path):

head, tail = os.path.split(path)

if head == "":

return splitpath(head)

return splitpath(head) + [tail]

class FolderTree(wx.Panel):

def __init__(self, parent, folder, filter=None, editable=True):

# Library Panel

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

class LibraryPanel(wx.Panel):

def __init__(self, parent, enable_drag=False):

"""

from dialogs.BrowseLocationsDialog import BrowseLocationsDialog

class LocationCellControl(wx.PyControl):

'''

def SetFocus(self):

self.Location.SetFocus()

class LocationCellEditor(wx.grid.PyGridCellEditor):

'''

Grid cell editor that uses LocationCellControl to display a browse button.

THUMB_SIZE_RATIO = 1. / 8.

def ArrowPoints(direction, width, height, xoffset, yoffset):

if direction == wx.TOP:

return [wx.Point(xoffset + 1, yoffset + height - 2),

wx.Point(xoffset + width / 2, yoffset - 2),

wx.Point(xoffset + width - 1, yoffset - height + 1)]

class LogScrollBar(wx.Panel):

def __init__(self, parent, size):

BUTTON_SIZE = (70, 15)

class LogButton():

def __init__(self, label, callback):

DATE_INFO_SIZE = 10

MESSAGE_INFO_SIZE = 18

class LogMessage:

def __init__(self, tv_sec, tv_nsec, level, level_bitmap, msg):

(_("1m"), MINUTE),

(_("1s"), SECOND)]

class LogViewer(DebugViewer, wx.Panel):

def __init__(self, parent, window):

# Customize CustomTreeItem for adding icon on item right

CT.GenericTreeItem._rightimages = []

def SetRightImages(self, images):

self._rightimages = images

CT.GenericTreeItem.SetRightImages = SetRightImages

def GetRightImages(self):

return self._rightimages

CT.GenericTreeItem.GetRightImages = GetRightImages

from PLCControler import ITEMS_VARIABLE, ITEM_CONFIGURATION, ITEM_RESOURCE, ITEM_POU, ITEM_TRANSITION, ITEM_ACTION

from util.BitmapLibrary import GetBitmap

class PouInstanceVariablesPanel(wx.Panel):

def __init__(self, parent, window, controller, debug):

# Project Properties Panel

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

class ProjectPropertiesPanel(wx.Notebook):

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

from PLCControler import *

from util.BitmapLibrary import GetBitmap

def GenerateName(infos):

if infos[0] in ["input", "output", "value"]:

return "%s %d:" % (infos[0], infos[1])

ID_SEARCHRESULTPANELSEARCHRESULTSTREE, ID_SEARCHRESULTPANELRESETBUTTON,

] = [wx.NewId() for _init_ctrls in range(4)]

class SearchResultPanel(wx.Panel):

if wx.VERSION < (2, 6, 0):

LISTBOX_BORDER_HEIGHT = 4

LISTBOX_INTERVAL_HEIGHT = 6

class PopupWithListbox(wx.PopupWindow):

def __init__(self, parent, choices=[]):

self.ListBox.HitTest(wx.Point(event.GetX(), event.GetY())))

event.Skip()

class TextCtrlAutoComplete(wx.TextCtrl):

def __init__ (self, parent, choices=None, dropDownClick=True,

POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

] = range(10)

def GetVariableTableColnames(location):

_ = lambda x : x

if location:

return ["#", _("Name"), _("Class"), _("Type"), _("Location"), _("Initial Value"), _("Option"), _("Documentation")]

return ["#", _("Name"), _("Class"), _("Type"), _("Initial Value"), _("Option"), _("Documentation")]

def GetOptions(constant=True, retain=True, non_retain=True):

_ = lambda x : x

options = [""]

return options

OPTIONS_DICT = dict([(_(option), option) for option in GetOptions()])

def GetFilterChoiceTransfer():

_ = lambda x : x

return {_("All"): _("All"), _("Interface"): _("Interface"),

# Variables Panel Table

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

class VariableTable(CustomTable):

"""

# Variable Panel Drop Target

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

class VariableDropTarget(wx.TextDropTarget):

'''

This allows dragging a variable location from somewhere to the Location

# Variable Panel

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

class VariablePanel(wx.Panel):

def __init__(self, parent, window, controler, element_type, debug=False):

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

def ShowAboutDialog(parent, info):

if os.name == "nt":

AboutDialog(parent, info)

# Helpers

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

def GetActionTableColnames():

_ = lambda x: x

return [_("Qualifier"), _("Duration"), _("Type"), _("Value"), _("Indicator")]

def GetTypeList():

_ = lambda x: x

return [_("Action"), _("Variable"), _("Inline")]

# Action Table

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

class ActionTable(CustomTable):

def GetValue(self, row, col):

# Action Block Dialog

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

class ActionBlockDialog(wx.Dialog):

def __init__(self, parent):

# Array Type Dialog

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

class ArrayTypeDialog(wx.Dialog):

def __init__(self, parent, datatypes, infos):

# Dialog with preview for graphic block

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

class BlockPreviewDialog(wx.Dialog):

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

"""

# Helpers

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

def GetDirFilterChoiceOptions():

_ = lambda x : x

return [(_("All"), [LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY]),

(_("Memory"), [LOCATION_VAR_MEMORY])]

DIRFILTERCHOICE_OPTIONS = dict([(_(option), filter) for option, filter in GetDirFilterChoiceOptions()])

def GetTypeFilterChoiceOptions():

_ = lambda x : x

return [_("All"),

# Browse Locations Dialog

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

class BrowseLocationsDialog(wx.Dialog):

def __init__(self, parent, var_type, controller):

# Set Connection Parameters Dialog

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

class ConnectionDialog(BlockPreviewDialog):

def __init__(self, parent, controller, tagname, apply_button=False):

"""

service_type = '_PYRO._tcp.local.'

class AutoWidthListCtrl(wx.ListCtrl, listmix.ListCtrlAutoWidthMixin):

def __init__(self, parent, id, name, pos=wx.DefaultPosition,

size=wx.DefaultSize, style=0):

ID_DISCOVERYDIALOGLOCALBUTTON, ID_DISCOVERYDIALOGIPBUTTON,

] = [wx.NewId() for _init_ctrls in range(6)]

class DiscoveryDialog(wx.Dialog, listmix.ColumnSorterMixin):

def _init_coll_MainSizer_Items(self, parent):

# Edit Duration Value Dialog

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

class DurationEditorDialog(wx.Dialog):

def __init__(self, parent):

# Helpers

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

def GetBlockTypeDefaultNameModel(blocktype):

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

# Set Block Parameters Dialog

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

class FBDBlockDialog(BlockPreviewDialog):

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

"""

# Set Variable Parameters Dialog

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

class FBDVariableDialog(BlockPreviewDialog):

def __init__(self, parent, controller, tagname, exclude_input=False):

"""

import wx

from plcopen.plcopen import *

class FindInPouDialog(wx.Dialog):

def _init_icon(self, parent):

"D" : ["DINT", "UDINT", "REAL", "DWORD"],

"L" : ["LINT", "ULINT", "LREAL", "LWORD"]}

def gen_get_function(f):

def get_function(v):

try:

return None

return get_function

def gen_get_string(delimiter):

STRING_MODEL = re.compile("%(delimiter)s([^%(delimiter)s]*)%(delimiter)s$" % {"delimiter": delimiter})

def get_string(v):

IEC_DATETIME_MODEL = re.compile("(?:(?:DT|DATE_AND_TIME)#)?([0-9]{4})-([0-9]{2})-([0-9]{2})-([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]+)?)$")

IEC_TIMEOFDAY_MODEL = re.compile("(?:(?:TOD|TIME_OF_DAY)#)?([0-9]{2}):([0-9]{2}):([0-9]{2}(?:\.[0-9]+)?)$")

def gettime(v):

result = IEC_TIME_MODEL.match(v.upper())

if result is not None:

else:

return None

def getdate(v):

result = IEC_DATE_MODEL.match(v.upper())

if result is not None:

else:

return None

def getdatetime(v):

result = IEC_DATETIME_MODEL.match(v.upper())

if result is not None:

else:

return None

def gettimeofday(v):

result = IEC_TIMEOFDAY_MODEL.match(v.upper())

if result is not None:

# Force Variable Dialog

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

class ForceVariableDialog(wx.TextEntryDialog):

def __init__(self, parent, iec_type, defaultValue=""):

# Set Ladder Element Parmeters Dialog

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

class LDElementDialog(BlockPreviewDialog):

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

"""

# Set Ladder Power Rail Parameters Dialog

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

class LDPowerRailDialog(BlockPreviewDialog):

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

"""

Constructor

from plcopen.structures import TestIdentifier, IEC_KEYWORDS

def GetActionLanguages():

_ = lambda x : x

return [_("IL"), _("ST"), _("LD"), _("FBD")]

ACTION_LANGUAGES_DICT = dict([(_(language), language) for language in GetActionLanguages()])

class PouActionDialog(wx.Dialog):

def __init__(self, parent):

from plcopen.structures import TestIdentifier, IEC_KEYWORDS

def GetPouTypes():

_ = lambda x : x

return [_("function"), _("functionBlock"), _("program")]

POU_TYPES_DICT = dict([(_(pou_type), pou_type) for pou_type in GetPouTypes()])

def GetPouLanguages():

_ = lambda x : x

return [_("IL"), _("ST"), _("LD"), _("FBD"), _("SFC")]

class PouDialog(wx.Dialog):

POU_LANGUAGES = GetPouLanguages()

# POU Name Dialog

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

class PouNameDialog(wx.TextEntryDialog):

def __init__(self, parent, message, caption = "Please enter text", defaultValue = "",

# POU Transition Dialog

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

def GetTransitionLanguages():

_ = lambda x : x

return [_("IL"), _("ST"), _("LD"), _("FBD")]

TRANSITION_LANGUAGES_DICT = dict([(_(language), language) for language in GetTransitionLanguages()])

class PouTransitionDialog(wx.Dialog):

def __init__(self, parent):

from controls.ProjectPropertiesPanel import ProjectPropertiesPanel

class ProjectDialog(wx.Dialog):

def __init__(self, parent, enable_required=True):

# Create New Divergence Dialog

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

class SFCDivergenceDialog(BlockPreviewDialog):

def __init__(self, parent, controller, tagname, poss_div_types = None):

"""

# Set SFC Step Parameters Dialog

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

class SFCStepDialog(BlockPreviewDialog):

def __init__(self, parent, controller, tagname, initial=False):

"""

# Edit Step Name Dialog

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

class SFCStepNameDialog(wx.TextEntryDialog):

def __init__(self, parent, message, caption = "Please enter text", defaultValue = "",

# Set Transition Parameters Dialog

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

class SFCTransitionDialog(BlockPreviewDialog):

def __init__(self, parent, controller, tagname, connection=True):

"""

# Search In Project Dialog

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

def GetElementsChoices():

_ = lambda x: x

return [("datatype", _("Data Type")),

("program", _("Program")),

("configuration", _("Configuration"))]

class SearchInProjectDialog(wx.Dialog):

def __init__(self, parent):

HtmlFrameOpened = []

def OpenHtmlFrame(self, title, file, size):

if title not in HtmlFrameOpened:

HtmlFrameOpened.append(title)

[ID_HTMLFRAME, ID_HTMLFRAMEHTMLCONTENT] = [wx.NewId() for _init_ctrls in range(2)]

EVT_HTML_URL_CLICK = wx.NewId()

class HtmlWindowUrlClick(wx.PyEvent):

def __init__(self, linkinfo):

wx.PyEvent.__init__(self)

self.SetEventType(EVT_HTML_URL_CLICK)

self.linkinfo = (linkinfo.GetHref(), linkinfo.GetTarget())

class UrlClickHtmlWindow(wx.html.HtmlWindow):

""" HTML window that generates and OnLinkClicked event.

else:

wx.html.HtmlWindow.Bind(event, handler, source=source, id=id, id2=id2)

class HtmlFrame(wx.Frame):

def _init_ctrls(self, prnt):

wx.Frame.__init__(self, id=ID_HTMLFRAME, name='HtmlFrame',

readerexepath = None

def get_acroversion():

" Return version of Adobe Acrobat executable or None"

import _winreg

pass

return None

def open_win_pdf(readerexepath, pdffile, pagenum = None):

if pagenum != None :

os.spawnl(os.P_DETACH, readerexepath, "AcroRd32.exe", "/A", "page=%d=OpenActions" % pagenum, '"%s"' % pdffile)

else:

os.spawnl(os.P_DETACH, readerexepath, "AcroRd32.exe", '"%s"' % pdffile)

def open_lin_pdf(readerexepath, pdffile, pagenum = None):

if pagenum == None :

os.system("%s -remote DS301 %s &" % (readerexepath, pdffile))

print "Open pdf %s at page %d" % (pdffile, pagenum)

os.system("%s -remote DS301 %s %d &" % (readerexepath, pdffile, pagenum))

def open_pdf(pdffile, pagenum = None):

if wx.Platform == '__WXMSW__' :

try:

import os

import subprocess

def get_inkscape_path():

""" Return the Inkscape path """

import _winreg

svgexepath = svgexepath.replace('"%1"', '')

return svgexepath.replace('"', '')

def open_win_svg(svgexepath, svgfile):

""" Open Inkscape on Windows platform """

popenargs = [svgexepath]

popenargs.append(svgfile)

subprocess.Popen(popenargs).pid

def open_lin_svg(svgexepath, svgfile):

""" Open Inkscape on Linux platform """

if os.path.isfile("/usr/bin/inkscape"):

os.system("%s %s &" % (svgexepath , svgfile))

def open_svg(svgfile):

""" Generic function to open SVG file """

if wx.Platform == '__WXMSW__' :

EDGE_COLUMN = 80

class CodeEditor(CustomStyledTextCtrl):

KEYWORDS = []

SCROLLBAR_UNIT = 10

class GenBitmapTextButton(wx.lib.buttons.GenBitmapTextButton):

def _GetLabelSize(self):

""" used internally """

style,

name)

class ConfTreeNodeEditor(EditorPanel):

SHOW_BASE_PARAMS = True

DIMENSION_MODEL = re.compile("([0-9]+)\.\.([0-9]+)$")

def AppendMenu(parent, help, id, kind, text):

parent.Append(help=help, id=id, kind=kind, text=text)

def GetElementsTableColnames():

_ = lambda x : x

return ["#", _("Name"), _("Type"), _("Initial Value")]

def GetDatatypeTypes():

_ = lambda x : x

return [_("Directly"), _("Subrange"), _("Enumerated"), _("Array"), _("Structure")]

# Structure Elements Table

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

class ElementsTable(CustomTable):

"""

# Datatype Editor class

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

class DataTypeEditor(EditorPanel):

def _init_Editor(self, parent):

# Debug Viewer Class

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

class DebugViewer:

def __init__(self, producer, debug, subscribe_tick=True):

"""

from controls import VariablePanel

class EditorPanel(wx.SplitterWindow):

VARIABLE_PANEL_TYPE = None

FILTER = _("All files (*.*)|*.*|CSV files (*.csv)|*.csv")

class FileManagementPanel(EditorPanel):

def _init_Editor(self, parent):

from editors.TextViewer import TextViewer

from plcopen.plcopen import TestTextElement

class IECCodeViewer(TextViewer):

def __del__(self):

from Viewer import *

def ExtractNextBlocks(block, block_list):

current_list = [block]

while len(current_list) > 0:

next_list.append(next)

current_list = next_list

def CalcBranchSize(elements, stops):

branch_size = 0

stop_list = stops

return 1

return branch_size

def RemoveElement(remove, element_tree):

if remove in element_tree and element_tree[remove]:

for child in element_tree[remove]["children"]:

element_tree.pop(remove)

## element_tree[remove] = None

def GenerateTree(element, element_tree, stop_list):

if element in element_tree:

connectors = element.GetConnectors()

element_tree[next] = {"parents":[element], "children":[], "weight":None}

GenerateTree(next, element_tree, stop_list)

def CalcWeight(element, element_tree):

weight = 0

parts = None

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

class LD_Viewer(Viewer):

def __init__(self, parent, tagname, window, controler, debug = False, instancepath = ""):

Viewer.__init__(self, parent, tagname, window, controler, debug, instancepath)

from EditorPanel import EditorPanel

from ConfTreeNodeEditor import ConfTreeNodeEditor

class ProjectNodeEditor(ConfTreeNodeEditor):

SHOW_BASE_PARAMS = False

[ID_CONFIGURATIONEDITOR,

] = [wx.NewId() for _init_ctrls in range(1)]

class ConfigurationEditor(EditorPanel):

ID = ID_CONFIGURATIONEDITOR

_ = lambda x : x

return [_("Name"), _("Triggering"), _("Single"), _("Interval"), _("Priority")]

def GetTaskTriggeringOptions():

_ = lambda x : x

return [_("Interrupt"), _("Cyclic")]

SingleCellEditor = lambda *x : wx.grid.GridCellChoiceEditor()

def CheckSingle(single, varlist):

return single in varlist

_ = lambda x : x

return [_("Name"), _("Type"), _("Task")]

class ResourceTable(CustomTable):

"""

SEARCH_RESULT_HIGHLIGHT: STC_PLC_SEARCH_RESULT,

}

def LineStartswith(line, symbols):

return reduce(lambda x, y: x or y, map(lambda x: line.startswith(x), symbols), False)

class TextViewer(EditorPanel):

ID = ID_TEXTVIEWER

CURSORS = None

SFC_Objects = (SFC_Step, SFC_ActionBlock, SFC_Transition, SFC_Divergence, SFC_Jump)

def ResetCursors():

global CURSORS

if CURSORS == None:

wx.StockCursor(wx.CURSOR_SIZEWE),

wx.StockCursor(wx.CURSOR_SIZENS)]

def AppendMenu(parent, help, id, kind, text):

if wx.VERSION >= (2, 6, 0):

parent.Append(help=help, id=id, kind=kind, text=text)

MAX_ZOOMIN = 7

ZOOM_FACTORS = [math.sqrt(2) ** x for x in xrange(-6, MAX_ZOOMIN)]

def GetVariableCreationFunction(variable_type):

def variableCreationFunction(viewer, id, specific_values):

return FBD_Variable(viewer, variable_type,

specific_values.execution_order)

return variableCreationFunction

def GetConnectorCreationFunction(connector_type):

def connectorCreationFunction(viewer, id, specific_values):

return FBD_Connector(viewer, connector_type,

specific_values.name, id)

return connectorCreationFunction

def commentCreationFunction(viewer, id, specific_values):

return Comment(viewer, specific_values.content, id)

def GetPowerRailCreationFunction(powerrail_type):

def powerRailCreationFunction(viewer, id, specific_values):

return LD_PowerRail(viewer, powerrail_type, id,

(False, "rising"): CONTACT_RISING,

(False, "falling"): CONTACT_FALLING}

def contactCreationFunction(viewer, id, specific_values):

contact_type = CONTACT_TYPES.get((NEGATED_VALUE(specific_values.negated),

MODIFIER_VALUE(specific_values.edge)),

(False, "rising", "none"): COIL_RISING,

(False, "falling", "none"): COIL_FALLING}

def coilCreationFunction(viewer, id, specific_values):

coil_type = COIL_TYPES.get((NEGATED_VALUE(specific_values.negated),

MODIFIER_VALUE(specific_values.edge),

COIL_NORMAL)

return LD_Coil(viewer, coil_type, specific_values.name, id)

def stepCreationFunction(viewer, id, specific_values):

step = SFC_Step(viewer, specific_values.name,

specific_values.initial, id)

connector.SetPosition(wx.Point(*specific_values.action.position))

return step

def transitionCreationFunction(viewer, id, specific_values):

transition = SFC_Transition(viewer, specific_values.condition_type,

specific_values.condition,

divergence_types = [SELECTION_DIVERGENCE,

SELECTION_CONVERGENCE, SIMULTANEOUS_DIVERGENCE, SIMULTANEOUS_CONVERGENCE]

def GetDivergenceCreationFunction(divergence_type):

def divergenceCreationFunction(viewer, id, specific_values):

return SFC_Divergence(viewer, divergence_type,

specific_values.connectors, id)

return divergenceCreationFunction

def jumpCreationFunction(viewer, id, specific_values):

return SFC_Jump(viewer, specific_values.target, id)

def actionBlockCreationFunction(viewer, id, specific_values):

return SFC_ActionBlock(viewer, specific_values.actions, id)

"actionBlock": actionBlockCreationFunction,

}

def sort_blocks(block_infos1, block_infos2):

x1, y1 = block_infos1[0].GetPosition()

x2, y2 = block_infos2[0].GetPosition()

dc.DrawText(text, x + tw, y)

dc.SetUserScale(scalex, scaley)

class Viewer(EditorPanel, DebugViewer):

if wx.VERSION < (2, 6, 0):

def Bind(self, event, function, id = None):

# Date corresponding to Epoch (1970 January the first)

DATE_ORIGIN = datetime.datetime(1970, 1, 1)

def get_microseconds(value):

"""

Function converting time duration expressed in day, second and microseconds

value.microseconds)

return

def generate_time(value):

"""

Function converting time duration expressed in day, second and microseconds

return data

def generate_date(value):

"""

Function converting time duration expressed in day, second and microseconds

"""

return (DATE_ORIGIN + value).strftime("DATE#%Y-%m-%d")

def generate_datetime(value):