self.MainTabs["LogConsole"] = (self.LogConsole, _("Console"))

self.BottomNoteBook.AddPage(*self.MainTabs["LogConsole"])

self.LogViewer = LogViewer(self.BottomNoteBook, self)

self.MainTabs["LogViewer"] = (self.LogViewer, _("PLC Log"))

self.BottomNoteBook.AddPage(*self.MainTabs["LogViewer"])

StatusToolBar = wx.ToolBar(self, -1, wx.DefaultPosition, wx.DefaultSize,

wx.TB_FLAT | wx.TB_NODIVIDER | wx.NO_BORDER)

self._Refresh(TITLE, FILEMENU, PROJECTTREE)

dialog.Destroy()

# Highlights showing functions

def ShowHighlight(self, infos, start, end, highlight_type):

config_name = self.Controler.GetProjectMainConfigurationName()

IDEFrame.ShowHighlight(self, infos, start, end, highlight_type)

# Exception Handler

import threading

import traceback

bug_report_path = path + os.sep + "bug_report_" + time.strftime("%Y_%m_%d__%H-%M-%S") + ".txt"

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

Display_Exception_Dialog(e_type, e_value, e_traceback, bug_report_path)

sys.excepthook = handle_exception

init_old = threading.Thread.__init__

if variable.getonchange()])

return ret

# Current Buffering Management Functions

"""

Return a copy of the codefile model

return self.CTNParent.RemoteExec(script, **kwargs)

def OnCTNSave(self, from_project_path=None):

return True

def GetParamsAttributes(self, path=None):

# Get Current Name

CurrentName = self.BaseParams.getName()

# Do nothing if no change

# Build a list of used Name out of parent's Children

AllNames = []

for CTNInstance in self.CTNParent.IterChildren():

# Get Current IEC channel

CurrentChannel = self.BaseParams.getIEC_Channel()

# Do nothing if no change

# Build a list of used Channels out of parent's Children

AllChannels = self.GetAllChannels()

def CTNRemove(self):

# Fetch the confnode

# Ask to his parent to remove it

self.CTNParent._doRemoveChild(self)

ID_PLCOPENEDITORDISPLAYMENUSWITCHPERSPECTIVE,

] = [wx.NewId() for _init_coll_DisplayMenu_Items in range(2)]

# EditorToolBar definitions

# Define PLCOpenEditor Toolbar items id

[

"move", _("Move the view"))],

}

# Helper Functions

import base64

return ComputeTabsLayout(tabs, rect)

return tabs

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

class IDEFrame(wx.Frame):

# Compatibility function for wx versions < 2.6

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

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

kind=wx.ITEM_NORMAL, text=_(u'Undo') + '\tCTRL+Z')

AppendMenu(parent, help='', id=wx.ID_REDO,

kind=wx.ITEM_NORMAL, text=_(u'Redo') + '\tCTRL+Y')

# kind=wx.ITEM_CHECK, text=_(u'Enable Undo/Redo'))

enable_undo_redo = _(u'Enable Undo/Redo') # Keeping text in translations for possible menu reactivation

parent.AppendSeparator()

kind=wx.ITEM_NORMAL, text=_(u'&Delete'))

self.Bind(wx.EVT_MENU, self.OnUndoMenu, id=wx.ID_UNDO)

self.Bind(wx.EVT_MENU, self.OnRedoMenu, id=wx.ID_REDO)

self.Bind(wx.EVT_MENU, self.OnCutMenu, id=wx.ID_CUT)

self.Bind(wx.EVT_MENU, self.OnCopyMenu, id=wx.ID_COPY)

self.Bind(wx.EVT_MENU, self.OnPasteMenu, id=wx.ID_PASTE)

self.TabsImageList = wx.ImageList(31, 16)

self.TabsImageListIndexes = {}

# Creating main structure

self.AUIManager = wx.aui.AuiManager(self)

self.AUIManager.SetDockSizeConstraint(0.5, 0.5)

self.AUIManager.AddPane(self.TabsOpened,

wx.aui.AuiPaneInfo().CentrePane().Name("TabsPane"))

# Creating PLCopen Project Types Tree

self.MainTabs = {}

id=ID_PLCOPENEDITORPROJECTTREE)

self.ProjectTree.Bind(wx.EVT_MOTION, self.OnProjectTreeMotion)

# Creating PLCopen Project POU Instance Variables Panel

self.PouInstanceVariablesPanel = PouInstanceVariablesPanel(self.ProjectPanel, self, self.Controler, self.EnableDebug)

self.ProjectPanel.SplitHorizontally(self.ProjectTree, self.PouInstanceVariablesPanel, 300)

# Creating Tool Bar

MenuToolBar = wx.ToolBar(self, ID_PLCOPENEDITOREDITORMENUTOOLBAR,

wx.DefaultPosition, wx.DefaultSize,

self.Bind(wx.EVT_MENU, self.OnSelectionTool,

id=ID_PLCOPENEDITOREDITORTOOLBARSELECTION)

# Creating Search Panel

self.SearchResultPanel = SearchResultPanel(self.BottomNoteBook, self)

self.MainTabs["SearchResultPanel"] = (self.SearchResultPanel, _("Search"))

self.BottomNoteBook.AddPage(*self.MainTabs["SearchResultPanel"])

# Creating Library Panel

self.LibraryPanel = LibraryPanel(self, True)

self.MainTabs["LibraryPanel"] = (self.LibraryPanel, _("Library"))

for imgname, itemtype in [

# editables

("PROJECT", ITEM_PROJECT),

("TRANSITION", ITEM_TRANSITION),

("ACTION", ITEM_ACTION),

("CONFIGURATION", ITEM_CONFIGURATION),

self.SearchParams = None

self.Highlights = {}

self.DrawingMode = FREEDRAWING_MODE

self.AuiTabCtrl = []

# Save default perspective

notebook.SetSelection(idx)

return

def GetTabInfos(self, tab):

for page_name, (page_ref, page_title) in self.MainTabs.iteritems():

self.Config.Flush()

def SetRefreshFunctions(self):

self.RefreshFunctions = {

PROJECTTREE, POUINSTANCEVARIABLESPANEL, SCALING)

dialog.Destroy()

def AddPage(self, window, text):

"""Function that add a tab in Notebook, calling refresh for tab DClick event

"""

return self.TabsOpened.SetPageBitmap(idx, bitmap)

def ShowErrorMessage(self, message):

"""Function displaying an Error dialog in editor.

return True

def RefreshFileMenu(self):

pass

def OnQuitMenu(self, event):

self.Close()

def RefreshEditMenu(self):

MenuToolBar = self.Panes["MenuToolBar"]

MenuToolBar.EnableTool(wx.ID_UNDO, undo)

self.EditMenu.Enable(wx.ID_REDO, redo)

MenuToolBar.EnableTool(wx.ID_REDO, redo)

# self.Controler.IsProjectBufferEnabled())

self.EditMenu.Enable(wx.ID_FIND, selected > -1)

self.EditMenu.Enable(ID_PLCOPENEDITOREDITMENUFINDNEXT,

MenuToolBar.EnableTool(wx.ID_UNDO, False)

self.EditMenu.Enable(wx.ID_REDO, False)

MenuToolBar.EnableTool(wx.ID_REDO, False)

self.EditMenu.Enable(wx.ID_CUT, False)

MenuToolBar.EnableTool(wx.ID_CUT, False)

self.EditMenu.Enable(wx.ID_COPY, False)

self.SearchResultPanel.SetSearchResults(criteria, result)

self.SelectTab(self.SearchResultPanel)

def RefreshDisplayMenu(self):

if self.Controler is not None:

def OnResetPerspective(self, event):

self.ResetPerspective()

def OnPageDragged(self, event):

wx.CallAfter(self.RefreshTabCtrlEvent)

self.AUIManager.MaximizePane(pane)

self.AUIManager.Update()

def RefreshProjectTree(self):

# Extract current selected item tagname

event.Skip()

def GetTreeImage(self, var_class):

return self.TreeImageDict[var_class]

self.DebugVariablePanel.InsertValue(iec_path, force=force, graph=graph)

self.EnsureTabVisible(self.DebugVariablePanel)

def RefreshLibraryPanel(self):

self.LibraryPanel.RefreshTree()

def AddToMenuToolBar(self, items):

MenuToolBar = self.Panes["MenuToolBar"]

self.CurrentMenu = menu

self.ResetCurrentMode()

def ResetCurrentMode(self):

selected = self.TabsOpened.GetSelection()

else:

self.TabsOpened.GetPage(selected).AddJump()

def OnAddNewProject(self, event):

# Asks user to create main program after creating new project

self._Refresh(TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, PROJECTTREE, LIBRARYTREE)

self.EditProjectElement(ITEM_POU, result[0])

def CheckElementIsUsedBeforeDeletion(self, check_function, title, name):

if not check_function(name):

self.TabsOpened.DeletePage(idx)

self._Refresh(TITLE, FILEMENU, EDITMENU, PROJECTTREE, POUINSTANCEVARIABLESPANEL)

def ShowHighlight(self, infos, start, end, highlight_type):

self.SelectProjectTreeItem(infos[0])

def ClearSearchResults(self):

self.ClearHighlights(SEARCH_RESULT_HIGHLIGHT)

# Viewer Printout

def UPPER_DIV(x, y):

dc.SetClippingRegion(posX, posY, self.PageSize[0] * scale, self.PageSize[1] * scale)

dc.SetUserScale(scale, scale)

self.Viewer.DoDrawing(dc, True)

return True

DATA_TYPES, TRANSITIONS, ACTIONS, CONFIGURATIONS,

RESOURCES, PROPERTIES] = UNEDITABLE_NAMES

class LibraryResolver(etree.Resolver):

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

self.Controller = controller

lib_el.append(deepcopy(ctn["types"]))

return self.resolve_string(etree.tostring(lib_el), context)

# Helpers functions for translating list of arguments

# from xslt to valid arguments

def _StringValue(x):

for translate, arg in

zip(translations, args)]

# Helpers object for generating pou var list

class _VariableInfos(object):

[_StringValue] * 5 + [_BoolValue] + [_StringValue], args) +

[self.GetType(), self.GetTree()])))

# Helpers object for generating pou variable instance list

def class_extraction(value):

[_StringValue, class_extraction, _StringValue] +

[_BoolValue] * 2, args) + [[]])))

class InstancesPathFactory:

def __init__(self, instances):

self.Instances = instances

def AddInstance(self, context, *args):

self.Instances.append(args[0][0])

class InstanceTagName:

def __init__(self, controller):

self.Controller = controller

def TransitionTagName(self, context, *args):

self.TagName = self.Controller.ComputePouTransitionName(args[0][0], args[0][1])

# Helpers object for generating pou block instances list

_Point = namedtuple("Point", ["x", "y"])

pou_block_instances_xslt = etree.parse(

os.path.join(ScriptDirectory, "plcopen", "pou_block_instances.xslt"))

# Length of the buffer

UNDO_BUFFER_LENGTH = 20

class UndoBuffer:

"""

Class implementing a buffer of changes made on the current editing model

"""

return self.LastSave == self.CurrentIndex

class PLCControler:

"""

Class which controls the operations made on the plcopen model and answers to view requests

"""

else:

return self.Project

# Return if a project is opened

def HasOpenedProject(self):

row, col = next_row, next_col

return infos

# Add a Data Type to Project

def ProjectAddDataType(self, datatype_name=None):

values.extend(confnodetype["types"].GetEnumeratedDataTypeValues())

return values

# Compute a data type name

def ComputeDataTypeName(self, datatype):

"R": ITEM_RESOURCE

}[words[0]]

# Return the data type informations

def GetDataTypeInfos(self, tagname, debug=False):

datatype.initialValue = None

self.BufferProject()

# Return edited element

def GetEditedElement(self, tagname, debug=False):

self.SetFilePath(filepath)

return True

def SearchInProject(self, criteria):

return self.Project.Search(criteria)

return search_results

return []

def Copy(self, model):

return deepcopy(model)

def CreateProjectBuffer(self, saved):

else:

return mylist

# Specific exception for PLC generating errors

class PLCGenException(Exception):

pass

# Generator of PLC program

class ProgramGenerator:

return self.Program

# Generator of POU programs

[ConnectorClass, ContinuationClass, ActionBlockClass] = [

PLCOpenParser.GetElementClass(instance_name, "commonObjects")

from dialogs import ProjectDialog

from dialogs.AboutDialog import ShowAboutDialog

# PLCOpenEditor Main Class

# Define PLCOpenEditor FileMenu extra items id

[

def _init_coll_HelpMenu_Items(self, parent):

AppendMenu(parent, help='', id=wx.ID_HELP,

kind=wx.ITEM_NORMAL, text=_(u'PLCOpenEditor') + '\tF1')

# kind=wx.ITEM_NORMAL, text=u'PLCOpen\tF2')

# kind=wx.ITEM_NORMAL, text=u'IEC 61131-3\tF3')

def handler(event):

AppendMenu(parent, help='', id=wx.ID_ABOUT,

kind=wx.ITEM_NORMAL, text=_(u'About'))

self.Bind(wx.EVT_MENU, self.OnPLCOpenEditorMenu, id=wx.ID_HELP)

self.Bind(wx.EVT_MENU, self.OnAboutMenu, id=wx.ID_ABOUT)

def __init__(self, parent, fileOpen=None):

else:

self.SetTitle(name)

def RefreshFileMenu(self):

MenuToolBar = self.Panes["MenuToolBar"]

self._Refresh(TITLE, FILEMENU, PAGETITLES)

dialog.Destroy()

# Exception Handler

Max_Traceback_List_Size = 20

for a in lst:

output.write(a+":\n"+str(info[a])+"\n\n")

sys.excepthook = handle_exception

"init_calls": "\n ".join([

"init_level=%d; " % (i+1) +

"if((res = __init_%s(argc,argv))){" % locstr +

"return res;}" for i, locstr in enumerate(locstrs)]),

"cleanup_calls": "\n ".join([

"if(init_level >= %d) " % i +

data_tuple = self.IECdebug_datas.get(IECPath, None)

if data_tuple is not None:

WeakCallableDict, data_log, status, fvalue, buffer_list = data_tuple

for weakcallable, buffer_list in WeakCallableDict.iteritems():

function = getattr(weakcallable, function_name, None)

if function is not None:

while (not self.debug_break) and (self._connector is not None):

plc_status, Traces = self._connector.GetTraceVariables()

debug_getvar_retry += 1

if plc_status == "Started":

if len(Traces) > 0:

Failed = False

self.logger.write_error(_("Couldn't stop PLC !\n"))

# debugthread should die on his own

wx.CallAfter(self.UpdateMethodsFromPLCStatus)

else:

status = ""

if self.previous_plcstate in ["Started", "Stopped"]:

if self.DebugAvailable() and self.GetIECProgramsAndVariables():

self.EnableMethod("_Transfer", True)

# warns controller that program match

self.ProgramTransferred()

else:

# self.logger.write_warning(

# _("Cannot compare latest build to target. Please build.\n"))

self.StyleSetSpec(stc.STC_C_OPERATOR, 'bold,size:%(size)d' % faces)

self.StyleSetSpec(stc.STC_C_STRINGEOL, 'back:#FFD5FF,size:%(size)d' % faces)

class CFileEditor(CodeFileEditor):

CONFNODEEDITOR_TABS = [

(_("C code"), "_create_CodePanel")]

from util.TranslationCatalogs import AddCatalog

AddCatalog(os.path.join(CanFestivalPath, "objdictgen", "locale"))

# Location Tree Helper

def GetSlaveLocationTree(slave_node, current_location, name):

"location": ".".join([str(i) for i in current_location]) + ".x",

"children": entries}

# SLAVE

class _SlaveCTN(NodeManager):

def GetBufferState(self):

return self.GetCurrentBufferState()

# MASTER

class MiniNodeManager(NodeManager):

TrashVariables = [(1, 0x01), (8, 0x05), (16, 0x06), (32, 0x07), (64, 0x1B)]

# Specific exception for PDO mapping errors

class PDOmappingException(Exception):

@param sync_TPDOs: indicate if TPDO must be synchronous

"""

# Verify that locations correspond to real slave variables

# Get list of locations check if exists and mappables -> put them in IECLocations

for location in locations:

_("Not PDO mappable variable : '{a1}' (ID:{a2},Idx:{a3},sIdx:{a4}))").

format(a1=name, a2=nodeid, a3="%x" % index, a4="%x" % subindex))

# Search for locations already mapped

for name, locationinfos in self.IECLocations.items():

node = self.NodeList.SlaveNodes[locationinfos["nodeid"]]["Node"]

self.LocationsNotMapped[locationinfos["nodeid"]] = {TPDO: [], RPDO: []}

self.LocationsNotMapped[locationinfos["nodeid"]][locationinfos["pdotype"]].append((name, locationinfos))

# Build concise DCF for the others locations

for nodeid, locations in self.LocationsNotMapped.items():

node = self.NodeList.SlaveNodes[nodeid]["Node"]

# Add number of params and data to node DCF

self.AddParamsToDCF(nodeid, dataparams, nbparams)

# Master Node Configuration

# Generate Master's Configuration from informations stored in MasterMapping

for cobid, pdo_infos in self.MasterMapping.items():

import sys

import traceback

import atexit

from twisted.internet import reactor, threads

from autobahn.twisted import wamp

from autobahn.twisted.websocket import WampWebSocketClientFactory, connectWS

errmess = traceback.format_exc()

confnodesroot.logger.write_error(errmess+"\n")

print errmess

return PLCObjDefaults.get(funcname)

return catcher_func

TOOLTIP_MAX_LINE = 5 # Maximum number of line in ToolTip

TOOLTIP_WAIT_PERIOD = 0.5 # Wait period before displaying tooltip in second

# Custom ToolTip

class CustomToolTip(wx.PopupWindow):

# Color for graph cursor

CURSOR_COLOR = '#800080'

# Debug Variable Graphic Viewer Helpers

def merge_ranges(ranges):

# Return range expended from 10 %

return center - range_size * 0.55, center + range_size * 0.55

# Debug Variable Graphic Viewer Drop Target

class DebugVariableGraphicDropTarget(wx.TextDropTarget):

dialog.Destroy()

# Debug Variable Graphic Viewer Class

class DebugVariableGraphicViewer(DebugVariableViewer, FigureCanvas):

from graphics.DebugDataConsumer import DebugDataConsumer, TYPE_TRANSLATOR

# Constant for calculate CRC for string variables

STRING_CRC_SIZE = 8

STRING_CRC_MASK = 2 ** STRING_CRC_SIZE - 1

# Debug Variable Item Class

class DebugVariableItem(DebugDataConsumer):

return next_tick

# Debug Variable Graphic Panel Drop Target

class DebugVariableDropTarget(wx.TextDropTarget):

dialog.Destroy()

class DebugVariablePanel(wx.Panel, DebugViewer):

"""

Class that implements a Viewer that display variable values as a graphs

from DebugVariableViewer import DebugVariableViewer

from GraphButton import GraphButton

# Debug Variable Text Viewer Drop Target

class DebugVariableTextDropTarget(wx.TextDropTarget):

dialog.Destroy()

# Debug Variable Text Viewer Class

class DebugVariableTextViewer(DebugVariableViewer, wx.Panel):

"""

HIGHLIGHT_RESIZE_PEN = wx.Pen(wx.Colour(200, 200, 200))

HIGHLIGHT_RESIZE_BRUSH = wx.Brush(wx.Colour(200, 200, 200))

# Base Debug Variable Viewer Class

class DebugVariableViewer:

from util.BitmapLibrary import GetBitmap

# Custom button for Graphic Viewer Class

class GraphButton():

import wx

# Helpers

[CATEGORY, BLOCK] = range(2)

# Library Panel

class LibraryPanel(wx.Panel):

event.x = size.width / 2

event.y = size.height / 2

event.SetEventObject(self.InstanceChoice)

self.InstanceChoice.GetEventHandler().ProcessEvent(event)

def OnParentButtonClick(self, event):

import wx

# Helpers

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

POUINSTANCEVARIABLESPANEL, LIBRARYTREE, SCALING, PAGETITLES

] = range(10)

# Project Properties Panel

class ProjectPropertiesPanel(wx.Notebook):

return "element %d %s" % (infos[1], infos[2])

return "%s:" % infos[0]

# Search Result Panel

[

self.SetChoices(choices)

# gp.Bind ( wx.EVT_MOVE , self.onControlChanged, gp )

# gp.Bind ( wx.EVT_SIZE , self.onControlChanged, gp )

# gp = gp.GetParent()

from util.BitmapLibrary import GetBitmap

from PLCControler import _VariableInfos

from util.TranslationCatalogs import NoTranslate

# Helpers

[

TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU, PROJECTTREE,

LOCATION_MODEL = re.compile("((?:%[IQM](?:\*|(?:[XBWLD]?[0-9]+(?:\.[0-9]+)*)))?)$")

VARIABLE_NAME_SUFFIX_MODEL = re.compile("([0-9]*)$")

# Variables Panel Table

class VariableTable(CustomTable):

grid.SetCellTextColour(row, col, highlight_colours[1])

self.ResizeRow(grid, row)

# Variable Panel Drop Target

class VariableDropTarget(wx.TextDropTarget):

message.ShowModal()

message.Destroy()

# Variable Panel

class VariablePanel(wx.Panel):

self.Controler.BufferProject()

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

def OnRefreshHighlightsTimer(self, event):

self.Table.ResetView(self.VariablesGrid)

from wx.lib.agw.hyperlink import HyperLinkCtrl

class AboutDialog(wx.Dialog):

"""

A replacement About Dialog for Windows, as it uses a generic frame that

CreditsDialog(self, self.info)

class CreditsDialog(wx.Dialog):

def __init__(self, parent, info):

wx.Dialog.__init__(self, parent, title=_("Credits"), size=(475, 320),

close.Bind(wx.EVT_BUTTON, lambda evt: self.Destroy())

class LicenseDialog(wx.Dialog):

def __init__(self, parent, info):

wx.Dialog.__init__(self, parent, title=_("License"), size=(500, 400),

close.Bind(wx.EVT_BUTTON, lambda evt: self.Destroy())

def ShowAboutDialog(parent, info):

if os.name == "nt":

from util.BitmapLibrary import GetBitmap

from PLCControler import _ActionInfos

from util.TranslationCatalogs import NoTranslate

# Helpers

def GetActionTableColnames():

_ = NoTranslate

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

# Action Table

class ActionTable(CustomTable):

grid.SetCellBackgroundColour(row, col, wx.WHITE)

self.ResizeRow(grid, row)

# Action Block Dialog

class ActionBlockDialog(wx.Dialog):

from controls import CustomEditableListBox

# Helpers

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

# Array Type Dialog

class ArrayTypeDialog(wx.Dialog):

from plcopen.structures import TestIdentifier, IEC_KEYWORDS

from graphics.GraphicCommons import FREEDRAWING_MODE

# Dialog with preview for graphic block

class BlockPreviewDialog(wx.Dialog):

from util.BitmapLibrary import GetBitmap

from util.TranslationCatalogs import NoTranslate

# Helpers

def GetDirFilterChoiceOptions():

for type in types:

LOCATION_SIZES[type] = size

# Browse Locations Dialog

class BrowseLocationsDialog(wx.Dialog):

from graphics.FBD_Objects import FBD_Connector

from BlockPreviewDialog import BlockPreviewDialog

# Set Connection Parameters Dialog

class ConnectionDialog(BlockPreviewDialog):

import wx

# Helpers

MICROSECONDS = 0.001

MILLISECONDS = 1

("Microseconds", _('Microseconds:')),

]

# Edit Duration Value Dialog

class DurationEditorDialog(wx.Dialog):

from controls.LibraryPanel import LibraryPanel

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

class FBDBlockDialog(BlockPreviewDialog):

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_REVERSE = dict(

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

# Set Variable Parameters Dialog

class FBDVariableDialog(BlockPreviewDialog):

import wx

# Helpers

LOCATIONDATATYPES = {"X": ["BOOL"],

"B": ["SINT", "USINT", "BYTE", "STRING"],

"DT": getdatetime,

"TOD": gettimeofday}

# Force Variable Dialog

class ForceVariableDialog(wx.TextEntryDialog):

from graphics.LD_Objects import LD_Contact, LD_Coil

from BlockPreviewDialog import BlockPreviewDialog

# Set Ladder Element Parmeters Dialog

class LDElementDialog(BlockPreviewDialog):

from graphics.LD_Objects import LD_PowerRail

from BlockPreviewDialog import BlockPreviewDialog

# Set Ladder Power Rail Parameters Dialog

class LDPowerRailDialog(BlockPreviewDialog):

import wx

# POU Name Dialog

class PouNameDialog(wx.TextEntryDialog):

from plcopen.structures import TestIdentifier, IEC_KEYWORDS

from util.TranslationCatalogs import NoTranslate

# POU Transition Dialog

def GetTransitionLanguages():

from graphics.SFC_Objects import SFC_Divergence

from BlockPreviewDialog import BlockPreviewDialog

# Create New Divergence Dialog

class SFCDivergenceDialog(BlockPreviewDialog):

from graphics.SFC_Objects import SFC_Step

from BlockPreviewDialog import BlockPreviewDialog

# Set SFC Step Parameters Dialog

class SFCStepDialog(BlockPreviewDialog):

import wx

# Edit Step Name Dialog

class SFCStepNameDialog(wx.TextEntryDialog):

from graphics.SFC_Objects import SFC_Transition

from BlockPreviewDialog import BlockPreviewDialog

# Set Transition Parameters Dialog

class SFCTransitionDialog(BlockPreviewDialog):

from plcopen.plcopen import *

from util.TranslationCatalogs import NoTranslate

# Search In Project Dialog

def GetElementsChoices():

# If extensions (or modules to document with autodoc) are in another directory,

# add these directories to sys.path here. If the directory is relative to the

# documentation root, use os.path.abspath to make it absolute, like shown here.

# -- General configuration -----------------------------------------------------

# If your documentation needs a minimal Sphinx version, state it here.

# Add any Sphinx extension module names here, as strings. They can be extensions

# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.

source_suffix = '.rst'

# The encoding of source files.

# The master toctree document.

master_doc = 'index'

# The language for content autogenerated by Sphinx. Refer to documentation

# for a list of supported languages.

gettext_compact = False

locale_dirs = ["locale/"]

# There are two options for replacing |today|: either, you set today to some

# non-false value, then it is used:

# Else, today_fmt is used as the format for a strftime call.

# List of patterns, relative to source directory, that match files and

# directories to ignore when looking for source files.

exclude_patterns = ['_build']

# The reST default role (used for this markup: `text`) to use for all documents.

# If true, '()' will be appended to :func: etc. cross-reference text.

# If true, the current module name will be prepended to all description

# unit titles (such as .. function::).

# If true, sectionauthor and moduleauthor directives will be shown in the

# output. They are ignored by default.

# The name of the Pygments (syntax highlighting) style to use.

pygments_style = 'sphinx'

# A list of ignored prefixes for module index sorting.

# -- Options for HTML output ---------------------------------------------------

# Theme options are theme-specific and customize the look and feel of a theme

# further. For a list of options available for each theme, see the

# documentation.

# Add any paths that contain custom themes here, relative to this directory.

# The name for this set of Sphinx documents. If None, it defaults to

# "<project> v<release> documentation".

# A shorter title for the navigation bar. Default is the same as html_title.

# The name of an image file (relative to this directory) to place at the top

# of the sidebar.

# The name of an image file (within the static path) to use as favicon of the

# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32

# pixels large.

# Add any paths that contain custom static files (such as style sheets) here,

# relative to this directory. They are copied after the builtin static files,

# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,

# using the given strftime format.

# If true, SmartyPants will be used to convert quotes and dashes to

# typographically correct entities.

# Custom sidebar templates, maps document names to template names.

# Additional templates that should be rendered to pages, maps page names to

# template names.

# If false, no module index is generated.

# If false, no index is generated.

# If true, the index is split into individual pages for each letter.

# If true, links to the reST sources are added to the pages.

# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.

# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.

# If true, an OpenSearch description file will be output, and all pages will

# contain a <link> tag referring to it. The value of this option must be the

# base URL from which the finished HTML is served.

# This is the file name suffix for HTML files (e.g. ".xhtml").

# Output file base name for HTML help builder.

htmlhelp_basename = 'Beremizdoc'

latex_elements = {

# The paper size ('letterpaper' or 'a4paper').

# The font size ('10pt', '11pt' or '12pt').

# Additional stuff for the LaTeX preamble.

}

# Grouping the document tree into LaTeX files. List of tuples

# The name of an image file (relative to this directory) to place at the top of

# the title page.

# For "manual" documents, if this is true, then toplevel headings are parts,

# not chapters.

# If true, show page references after internal links.

# If true, show URL addresses after external links.

# Documents to append as an appendix to all manuals.

# If false, no module index is generated.

# -- Options for manual page output --------------------------------------------

]

# If true, show URL addresses after external links.

# -- Options for Texinfo output ------------------------------------------------

]

# Documents to append as an appendix to all manuals.

# If false, no module index is generated.

# How to display URL addresses: 'footnote', 'no', or 'inline'.

self.RemoveHighlight(*self.CurrentFindHighlight)

self.CurrentFindHighlight = None

def OnRefreshHighlightsTimer(self, event):

self.RefreshView(True)

self.SetStyling(len(self.GetText()) - highlight_end_pos, stc.STC_STYLE_DEFAULT)

# Helper for VariablesGrid values

class VariablesTable(CustomTable):

event.Skip()

# CodeFileEditor Main Frame Class

class CodeFileEditor(ConfTreeNodeEditor):

from util.BitmapLibrary import GetBitmap

from util.TranslationCatalogs import NoTranslate

# Helpers

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

DATATYPE_TYPES_DICT = dict([(_(datatype), datatype) for datatype in GetDatatypeTypes()])

# Structure Elements Table

class ElementsTable(CustomTable):

col_highlights = row_highlights.setdefault(infos[1], [])

col_highlights.append(highlight_type)

# Datatype Editor class

class DataTypeEditor(EditorPanel):

self.ParentWindow.RefreshFileMenu()

self.ParentWindow.RefreshEditMenu()

def OnRefreshHighlightsTimer(self, event):

self.RefreshView()

REFRESH_PERIOD = 0.1 # Minimum time between 2 refresh

DEBUG_REFRESH_LOCK = Lock() # Common refresh lock for all debug viewers

# Debug Viewer Class

class DebugViewer:

element_tree[element]["weight"] = max(1, weight / parts)

# Ladder Diagram Graphic elements Viewer class

class LD_Viewer(Viewer):

self.RungComments = []

self.CurrentLanguage = "LD"

def ResetView(self):

self.Rungs = []

if not inserted:

self.RungComments.append(element)

def FindRung(self, element):

for i, rung in enumerate(self.Rungs):

elements.append(element)

return elements

def OnViewerLeftDown(self, event):

if self.GetDrawingMode() == FREEDRAWING_MODE:

wx.CallAfter(self.SetCurrentCursor, 0)

event.Skip()

def OnChar(self, event):

if self.GetDrawingMode() == FREEDRAWING_MODE:

else:

event.Skip()

def AddVariableBlock(self, x, y, scaling, var_class, var_name, var_type):

if var_type == "BOOL":

else:

Viewer.AddVariableBlock(self, x, y, scaling, var_class, var_name, var_type)

def AddLadderRung(self):

dialog = LDElementDialog(self.ParentWindow, self.Controler, "coil")

message.ShowModal()

message.Destroy()

def DeleteContact(self, contact):

if self.GetDrawingMode() == FREEDRAWING_MODE:

self.RefreshRungs(new_bbox.height - old_bbox.height, rungindex + 1)

self.SelectedElement = None

def RefreshPosition(self, element, recursive=True):

# If element is LeftPowerRail, no need to update position

if self.IsBlock(element):

self.RefreshPosition(element)