bug_report*

syntax: regexp

^tests/.*/build$

syntax: regexp

^.*\.pyc$

syntax: regexp

^.*~$

syntax: regexp

^.*\.swp$

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

#

#

#

#

updateinfo_url = None

import shutil

import random

import time

from types import ListType

beremiz_dir = os.path.dirname(os.path.realpath(__file__))

from wx.lib.agw.advancedsplash import AdvancedSplash

def Bpath(*args):

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

if __name__ == '__main__':

def usage():

print "\nUsage of Beremiz.py :"

else :

__builtin__.__dict__["BMZ_DBG"] = False

app.SetAppName('beremiz')

# popup splash

if updateinfo_url is not None:

# warn for possible updates

def updateinfoproc():

global updateinfo

import urllib2

updateinfo = urllib2.urlopen(updateinfo_url,None).read()

except :

from threading import Thread

splash.SetText(text=updateinfo)

splash.SetText(text=updateinfo)

wx.Yield()

# Load extensions

for extfilename in extensions:

from util.TranslationCatalogs import AddCatalog

from util.ProcessLogger import ProcessLogger

from controls.LogViewer import LogViewer

from controls.CustomStyledTextCtrl import CustomStyledTextCtrl

from PLCControler import LOCATION_CONFNODE, LOCATION_MODULE, LOCATION_GROUP, LOCATION_VAR_INPUT, LOCATION_VAR_OUTPUT, LOCATION_VAR_MEMORY, ITEM_PROJECT, ITEM_RESOURCE

from ProjectController import ProjectController, GetAddMenuItems, MATIEC_ERROR_MODEL, ITEM_CONFNODE

# adding text. It seems that text modifications, even

# programmatically, are disabled in StyledTextCtrl when read

# only is active

self.output.SetReadOnly(False)

self.output.AppendText(s)

self.output.SetReadOnly(True)

if style != self.black_white:

self.stack = []

self.lock.release()

self.output.Thaw()

inspectorID = wx.NewId()

self.Bind(wx.EVT_MENU, self.OnOpenWidgetInspector, id=inspectorID)

accels = [wx.AcceleratorEntry(wx.ACCEL_CTRL|wx.ACCEL_ALT, ord('I'), inspectorID)]

for method,shortcut in [("Stop", wx.WXK_F4),

("Run", wx.WXK_F5),

("Transfer", wx.WXK_F6),

self.AUIManager.Update()

self._init_coll_ConnectionStatusBar_Fields(self.ConnectionStatusBar)

self.SetStatusBar(self.ConnectionStatusBar)

def __init__(self, parent, projectOpen=None, buildpath=None, ctr=None, debug=True):

IDEFrame.__init__(self, parent, debug)

self.Log = LogPseudoFile(self.LogConsole,self.SelectTab)

("Extension", ITEM_CONFNODE)]:

self.TreeImageDict[itemtype] = self.TreeImageList.Add(GetBitmap(imgname))

if projectOpen is not None:

projectOpen = DecodeFileSystemPath(projectOpen, False)

if projectOpen is not None and os.path.isdir(projectOpen):

self.CTR = ProjectController(self, self.Log)

self.Controler = self.CTR

if not result:

self.LibraryPanel.SetController(self.Controler)

self.ProjectTree.Enable(True)

{False : "-x 0", True :"-x 1"}[taskbaricon],

self.local_runtime_tmpdir),

no_gui=False,

cwd = self.local_runtime_tmpdir)

self.local_runtime.spin()

return self.runtime_port

self.GetConfigEntry("RecentProjects", []))

except:

recent_projects = []

self.FileMenu.Enable(ID_FILEMENURECENTPROJECTS, len(recent_projects) > 0)

for idx, projectpath in enumerate(recent_projects):

text = u'%d: %s' % (idx + 1, projectpath)

self.DebugVariablePanel.SetDataProducer(None)

self.ResetConnectionStatusBar()

try:

recent_projects = map(DecodeFileSystemPath,

self.GetConfigEntry("RecentProjects", []))

recent_projects = []

if projectpath in recent_projects:

recent_projects.remove(projectpath)

self.Config.Write("RecentProjects", cPickle.dumps(

map(EncodeFileSystemPath, recent_projects[:MAX_RECENT_PROJECTS])))

self.Config.Flush()

self.ResetView()

self.CTR = ProjectController(self, self.Log)

self.Controler = self.CTR

if not result:

self.LibraryPanel.SetController(self.Controler)

self.ProjectTree.Enable(True)

self.PouInstanceVariablesPanel.SetController(self.Controler)

if self.EnableDebug:

self.DebugVariablePanel.SetDataProducer(self.CTR)

self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

self.ResetView()

self.ShowErrorMessage(result)

self.RefreshAll()

else:

self.ShowErrorMessage(_("\"%s\" folder is not a valid Beremiz project\n") % projectpath)

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

def OnCloseProjectMenu(self, event):

if self.CTR is not None:

self.CTR.SaveProjectAs()

self.RefreshAll()

self._Refresh(TITLE, FILEMENU, EDITMENU, PAGETITLES)

def OnQuitMenu(self, event):

self.Close()

def OnAboutMenu(self, event):

def OnProjectTreeItemBeginEdit(self, event):

selected = event.GetItem()

Please be kind enough to send this file to:

beremiz-devel@lists.sourceforge.net

Traceback:

""") % bug_report_path +

if __name__ == '__main__':

# Install a exception handle for bug reports

frame = Beremiz(None, projectOpen, buildpath)

if splash:

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

#

#

#

#

import os, sys, getopt

from threading import Thread

if __name__ == '__main__':

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

if enablewx:

try:

import wxversion

import wx

havewx = True

except:

import re

from threading import Thread, currentThread

from types import *

defaulticon = wx.Image(Bpath("images", "brz.png"))

starticon = wx.Image(Bpath("images", "icoplay24.png"))

event(self, function)

style = wx.OK|wx.CANCEL|wx.CENTRE, pos = wx.DefaultPosition):

wx.TextEntryDialog.__init__(self, parent, message, caption, defaultValue, style, pos)

def OnTaskBarStartPLC(self, evt):

if self.pyroserver.plcobj is not None:

def OnTaskBarStopPLC(self, evt):

if self.pyroserver.plcobj is not None:

def OnTaskBarChangeInterface(self, evt):

dlg.SetTests([(re.compile('\d{1,3}(?:\.\d{1,3}){3}$').match, _("IP is not valid!")),

( lambda x :len([x for x in x.split(".") if 0 <= int(x) <= 255]) == 4, _("IP is not valid!"))

])

self.pyroserver.Stop()

def OnTaskBarChangeName(self, evt):

dlg.SetTests([(lambda name : len(name) is not 0 , _("Name must not be null!"))])

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

self.pyroserver.Restart()

def _LiveShellLocals(self):

def Quit(self):

self.continueloop = False

if self.plcobj is not None:

self.plcobj.UnLoadPLC()

self.Stop()

self.pyruntimevars)

uri = self.daemon.connect(self.plcobj,"PLCObject")

# Configure and publish service

# Not publish service if localhost in address params

self.ip_addr is not None and

self.ip_addr != "localhost" and

self.ip_addr != "127.0.0.1"):

self.servicepublisher = ServicePublisher.ServicePublisher()

self.servicepublisher.RegisterService(self.servicename, self.ip_addr, self.port)

self.plcobj.StartPLC()

sys.stdout.flush()

self.daemon.requestLoop()

def Stop(self):

if self.plcobj is not None:

havetwisted = True

except:

havetwisted = False

pyruntimevars = {}

try:

import runtime.NevowServer as NS

except Exception, e:

webport = None

NS.WorkingDir = WorkingDir

try:

import runtime.WampClient as WC

except Exception, e:

wampconf = None

# Load extensions

pyruntimevars["website"] = website

statuschange.append(NS.website_statuslistener_factory(website))

except Exception, e:

if wampconf is not None :

try:

pyruntimevars["wampsession"] = WC.GetSession

WC.SetServer(pyroserver)

except Exception, e:

if havetwisted or havewx:

import os, re, traceback

from copy import deepcopy

try:

self.CodeFile, error = self.CodeFileParser.LoadXMLString(codefile_xml)

if error is not None:

self.CreateCodeFileBuffer(True)

except Exception, exc:

self.GetCTRoot().logger.write_error(traceback.format_exc())

else:

self.CodeFile = self.CodeFileParser.CreateRoot()

"""

Config Tree Node base class.

</xsd:schema>""")

NameTypeSeparator = '@'

class ConfigTreeNode:

"""

shutil.move(oldname, self.CTNPath())

# warn user he has two left hands

if DesiredName != res:

return res

def GetAllChannels(self):

try:

CTNClass, CTNHelp = CTNChildrenTypes[CTNType]

except KeyError:

# if CTNClass is a class factory, call it. (prevent unneeded imports)

if type(CTNClass) == types.FunctionType:

ChildrenWithSameClass = self.Children.setdefault(CTNType, list())

# Check count

if getattr(CTNClass, "CTNMaxCount", None) and len(ChildrenWithSameClass) >= CTNClass.CTNMaxCount:

# create the final class, derived of provided confnode and template

class FinalCTNClass(CTNClass, ConfigTreeNode):

_self.LoadXMLParams(NewCTNName)

# Basic check. Better to fail immediately.

if (_self.BaseParams.getName() != NewCTNName):

# Now, self.CTNPath() should be OK

basexmlfile = open(self.ConfNodeBaseXmlFilePath(CTNName), 'r')

self.BaseParams, error = _BaseParamsParser.LoadXMLString(basexmlfile.read())

if error is not None:

self.MandatoryParams = ("BaseParams", self.BaseParams)

basexmlfile.close()

except Exception, exc:

self.GetCTRoot().logger.write_error(traceback.format_exc())

# Get the xml tree

xmlfile = open(self.ConfNodeXmlFilePath(CTNName), 'r')

obj, error = self.Parser.LoadXMLString(xmlfile.read())

if error is not None:

name = obj.getLocalTag()

setattr(self, name, obj)

self.CTNParams = (name, obj)

xmlfile.close()

except Exception, exc:

self.GetCTRoot().logger.write_error(traceback.format_exc())

def LoadChildren(self):

try:

self.CTNAddChild(pname, ptype)

except Exception, exc:

self.GetCTRoot().logger.write_error(traceback.format_exc())

import os, sys

import cPickle

# Define PLCOpenEditor DisplayMenu extra items id

[ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE,

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

# EditorToolBar definitions

self.Bind(wx.EVT_MENU, self.GenerateZoomFunction(idx), id=new_id)

parent.AppendSeparator()

AppendMenu(parent, help='', id=ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE,

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

self.Bind(wx.EVT_MENU, self.OnResetPerspective, id=ID_PLCOPENEDITORDISPLAYMENURESETPERSPECTIVE)

self._init_coll_DisplayMenu_Items(self.DisplayMenu)

self._init_coll_HelpMenu_Items(self.HelpMenu)

def _init_ctrls(self, prnt):

wx.Frame.__init__(self, id=ID_PLCOPENEDITOR, name='IDEFrame',

parent=prnt, pos=wx.DefaultPosition, size=wx.Size(1000, 600),

style=wx.DEFAULT_FRAME_STYLE)

self.SetClientSize(wx.Size(1000, 600))

self.Bind(wx.EVT_ACTIVATE, self.OnActivated)

def OnFindMenu(self, event):

if not self.FindDialog.IsShown():

self.FindDialog.Show()

def CloseFindInPouDialog(self):

selected = self.TabsOpened.GetSelection()

dialog = SearchInProjectDialog(self)

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

criteria = dialog.GetCriteria()

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

# Display Menu Functions

def OnTabsOpenedDClick(event):

pos = event.GetPosition()

if tabctrl.TabHitTest(pos.x, pos.y, None):

event.Skip()

return OnTabsOpenedDClick

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

# Types Tree Management Functions

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

item_name = _(item_name)

self.ProjectTree.SetItemText(root, item_name)

self.ProjectTree.SetPyData(root, infos)

self.ProjectTree.SetItemTextColour(root, highlight_colours[1])

self.ProjectTree.SetItemExtraImage(root, None)

if infos["type"] == ITEM_POU:

self.RefreshLibraryPanel()

self.RefreshPageTitles()

elif item_infos["type"] == ITEM_TRANSITION:

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames()]:

message = _("A POU named \"%s\" already exists!")%new_name

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariableNames(pou_name) if name != old_name]:

self.Controler.ComputePouTransitionName(words[1], new_name))

self.RefreshPageTitles()

elif item_infos["type"] == ITEM_ACTION:

if new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouNames()]:

message = _("A POU named \"%s\" already exists!")%new_name

elif new_name.upper() in [name.upper() for name in self.Controler.GetProjectPouVariableNames(pou_name) if name != old_name]:

if message or abort:

if message:

self.ShowErrorMessage(message)

event.Veto()

else:

wx.CallAfter(self.RefreshProjectTree)

self.Bind(wx.EVT_MENU, self.OnDeleteMenu, id=new_id)

if menu is not None:

menu.Destroy()

self.ResetSelectedItem()

import os

from POULibrary import POULibrary

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

#

#

#

#

from xml.dom import minidom

from types import StringType, UnicodeType, TupleType

# programs cannot be pasted as functions or function blocks

if orig_type == 'functionBlock' and pou_type == 'function' or \

orig_type == 'program' and pou_type in ['function', 'functionBlock']:

new_pou.setpouType(pou_type)

for dimension in element_type.getdimension():

dimensions.append((dimension.getlower(), dimension.getupper()))

base_type = element_type.baseType.getcontent()

element_infos["Type"] = ("array",

base_type.getname()

if base_type_type == "derived"

else:

element_infos["Type"] = element_type_type.upper()

if element.initialValue is not None:

else:

element_infos["Initial Value"] = ""

infos["elements"].append(element_infos)

else basetype_content_type.upper())

if datatype.initialValue is not None:

else:

infos["initial"] = ""

return infos

if element_infos["Type"][0] == "array":

array_type, base_type_name, dimensions = element_infos["Type"]

array = PLCOpenParser.CreateElement("array", "dataType")

element_type.setcontent(array)

for j, dimension in enumerate(dimensions):

dimension_range = PLCOpenParser.CreateElement("dimension", "array")

else:

array.appenddimension(dimension_range)

if base_type_name in self.GetBaseTypes():

base_type_name.lower()

if base_type_name in ["STRING", "WSTRING"]

else base_type_name, "dataType"))

if pou is not None:

return self.GetPouInterfaceReturnType(pou, tree, debug)

elif words[0] == 'T':

return None

# Change the edited element text

new_id = {}

try:

except:

instances, error = [], ""

if error is not None or len(instances) == 0:

def SearchInPou(self, tagname, criteria, debug=False):

pou = self.GetEditedElement(tagname, debug)

if pou is not None:

return []

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

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

#

#

#

#

from plcopen import PLCOpenParser

from plcopen.structures import *

single = task.getsingle()

# Single argument if exists

if single is not None:

if single[0]=='[' and single[-1]==']' :

SNGLKW = "MULTI"

else:

content = instance.getconditionContent()

if content["type"] == "connection":

self.ConnectionTypes[content["value"]] = "BOOL"

connected = self.GetLinkedConnector(link, body)

if connected is not None and not self.ConnectionTypes.has_key(connected):

for related in self.ExtractRelatedConnections(connected):

for element in body.getcontentInstances():

if isinstance(element, ConnectorClass) and element.getname() == name:

if connector is not None:

connector = element

if connector is not None:

undefined = [instance.connectionPointOut, connector.connectionPointIn]

for connection in related:

self.ConnectionTypes[connection] = var_type

else:

elif isinstance(instance, BlockClass):

block_infos = self.GetBlockType(instance.gettypeName(), "undefined")

if block_infos is not None:

if block_infos is None:

block_infos = self.GetBlockType(block_type)

if block_infos is None:

try:

self.GenerateBlock(instance, block_infos, body, None)

except ValueError, e:

self.Program += JoinList([(", ", ())], vars)

self.Program += [(");\n", ())]

else:

elif block_infos["type"] == "functionBlock":

if not self.ComputedBlocks.get(block, False) and not order:

self.ComputedBlocks[block] = True

if output_parameter is None:

output_parameter = ""

if name:

else:

blockname = type

def GeneratePaths(self, connections, body, order = False, to_inout = False):

paths = []

if block_infos is None:

block_infos = self.GetBlockType(block_type)

if block_infos is None:

try:

paths.append(str(self.GenerateBlock(next, block_infos, body, connection, order, to_inout)))

except ValueError, e:

for instance in body.getcontentInstances():

if isinstance(instance, ConnectorClass) and instance.getname() == name:

if connector is not None:

connector = instance

if connector is not None:

connections = connector.connectionPointIn.getconnections()

self.ComputedConnectors[name] = expression

paths.append(str(expression))

else:

elif isinstance(next, ContactClass):

contact_info = (self.TagName, "contact", next.getlocalId())

variable = str(self.ExtractModifier(next, [(next.getvariable(), contact_info + ("reference",))], contact_info))

def GenerateSFCJump(self, jump, pou):

jump_target = jump.gettargetName()

if jump.connectionPointIn is not None:

instances = []

connections = jump.connectionPointIn.getconnections()

elif len(transition_infos["from"]) == 1:

self.Program += transition_infos["from"][0]

else:

self.Program += [(" TO ", ())]

if len(transition_infos["to"]) > 1:

self.Program += [("(", ())]

elif len(transition_infos["to"]) == 1:

self.Program += transition_infos["to"][0]

else:

self.Program += transition_infos["content"]

self.Program += [("%sEND_TRANSITION\n\n"%self.CurrentIndent, ())]

for [(step_name, step_infos)] in transition_infos["to"]:

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

#

#

#

#

import wx

import os, sys, platform, time, traceback, getopt

beremiz_dir = os.path.dirname(os.path.realpath(__file__))

# Create wxApp (Need to create App before internationalization because of

# Windows)

from util.misc import InstallLocalRessources

InstallLocalRessources(beremiz_dir)

from editors.Viewer import Viewer

from PLCControler import PLCControler

from dialogs import ProjectDialog

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

# PLCOpenEditor Main Class

# @param fileOpen The filepath to open if no controler defined (default: None).

# @param debug The filepath to open if no controler defined (default: False).

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

IDEFrame.__init__(self, parent)

result = None

self._Refresh(PROJECTTREE, POUINSTANCEVARIABLESPANEL, LIBRARYTREE)

# Define PLCOpenEditor icon

self.Bind(wx.EVT_CLOSE, self.OnCloseFrame)

self._Refresh(TITLE, EDITORTOOLBAR, FILEMENU, EDITMENU, DISPLAYMENU)

if result is not None:

def OnCloseFrame(self, event):

if self.Controler is None or self.CheckSaveBeforeClosing(_("Close Application")):

dialog.Destroy()

if result is not None:

def OnCloseProjectMenu(self, event):

if not self.CheckSaveBeforeClosing():

open_pdf(os.path.join(beremiz_dir, "plcopen", "TC6_XML_V101.pdf"))

def OnAboutMenu(self, event):

def SaveProject(self):

result = self.Controler.SaveXMLFile()

dlg = wx.SingleChoiceDialog(None,

_("""

Please be kind enough to send this file to:

_("Error"),

trcbck_lst)

try:

sys.excepthook = handle_exception

if __name__ == '__main__':

# Install a exception handle for bug reports

frame = PLCOpenEditor(None, fileOpen=fileOpen)

from weakref import ref

class POULibrary:

"""

Beremiz Project Controller

"""

def GetAddMenuItems():

return ExtractMenuItemsFromCatalog(features.catalog)