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__))

app.SetAppName('beremiz')

if wx.VERSION < (3, 0, 0):

# popup splash

splash = ShowSplashScreen()

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):

# Add beremiz's icon in top left corner of the frame

self.icon = wx.Icon(Bpath("images", "brz.ico"), wx.BITMAP_TYPE_ICO)

IDEFrame.__init__(self, parent, debug)

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

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 +

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

def handle_exception(e_type, e_value, e_traceback):

traceback.print_exception(e_type, e_value, e_traceback) # this is very helpful when there's an exception in the rest of this func

last_tb = get_last_traceback(e_traceback)

ex = (last_tb.tb_frame.f_code.co_filename, last_tb.tb_frame.f_lineno)

if ex not in ignored_exceptions:

date = time.ctime()

#sys.excepthook = lambda *args: wx.CallAfter(handle_exception, *args)

sys.excepthook = handle_exception

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:

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()

</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())

# 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)

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]:

#!/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)

if pou is not None:

return self.GetPouInterfaceReturnType(pou, tree, debug)

elif words[0] == 'T':

return None

# Change the edited element text

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)

def GetAddMenuItems():

return ExtractMenuItemsFromCatalog(features.catalog)

class ProjectController(ConfigTreeNode, PLCControler):

"""

This class define Root object of the confnode tree.

self.DebugTicks = []

self.SetAppFrame(frame, logger)

# Setup debug information

self.IECdebug_datas = {}

self.IECdebug_lock = Lock()

return self

def GetIECLibPath(self):

def GetIEC2cPath(self):

def GetCurrentLocation(self):

return ()

# Verify that project contains a PLCOpen program

plc_file = os.path.join(ProjectPath, "plc.xml")

if not os.path.isfile(plc_file):

# Load PLCOpen file

error = self.OpenXMLFile(plc_file)

if error is not None:

if self.Project is not None:

else:

if len(self.GetProjectConfigNames()) == 0:

self.AddProjectDefaultConfiguration()

# Change XSD into class members

#Load the confnode.xml file into parameters members

result = self.LoadXMLParams()

if result:

#Load and init all the children

self.LoadChildren()

self.RefreshConfNodesBlockLists()

def RecursiveConfNodeInfos(self, confnode):

values = []

self.ClearChildren()

self.ResetAppFrame(None)

def SaveProject(self, from_project_path=None):

if self.CheckProjectPathPerm(False):

if from_project_path is not None:

if answer == wx.ID_OK:

newprojectpath = dirdialog.GetPath()

if os.path.isdir(newprojectpath):

return True

return False

return True

def _Compile_ST_to_SoftPLC(self):

self.logger.write(_("Compiling IEC Program into C code...\n"))

buildpath = self._getBuildPath()

buildcmd = "\"%s\" %s -I \"%s\" -T \"%s\" \"%s\""%(

buildpath,

self._getIECcodepath())

# Keep track of generated C files for later use by self.CTNGenerate_C

self.PLCGeneratedCFiles = C_files

# compute CFLAGS for plc

return True

def GetBuilder(self):

# Eventually create build dir

if not os.path.exists(buildpath):

os.mkdir(buildpath)

self.logger.flush()

self.logger.write(_("Start build in %s\n") % buildpath)

# Generate SoftPLC IEC code

IECGenRes = self._Generate_SoftPLC()

# If IEC code gen fail, bail out.

if not IECGenRes:

def ShowError(self, logger, from_location, to_location):

chunk_infos = self.GetChunkInfos(from_location, to_location)

for infos, (start_row, start_col) in chunk_infos:

if self.AppFrame is not None:

self.AppFrame.ShowError(infos, start, end)

except:

text = '(* No IEC code have been generated at that time ! *)'

self._IECCodeView.SetText(text = text)

self._IECCodeView.SetIcon(GetBitmap("ST"))

setattr(self._IECCodeView, "_OnClose", self.OnCloseEditor)

shutil.rmtree(os.path.join(self._getBuildPath()))

else:

self.logger.write_error(_("Build directory already clean\n"))

# kill the builder

self._builder = None

self.CompareLocalAndRemotePLC()

def UpdatePLCLog(self, log_count):

if log_count:

if self.AppFrame is not None:

self.AppFrame.LogViewer.SetLogCounters(log_count)

def UpdateMethodsFromPLCStatus(self):

status = None

if self._connector is not None:

PLCstatus = self._connector.GetPLCstatus()

self.ShowMethod(*args)

self.previous_plcstate = status

if self.AppFrame is not None:

self.AppFrame.RefreshStatusToolBar()

if status == "Disconnected":

self.AppFrame.ConnectionStatusBar.SetStatusText('', 2)

else:

self.AppFrame.ConnectionStatusBar.SetStatusText(

_("Connected to URI: %s") % self.BeremizRoot.getURI_location().strip(), 1)

def PullPLCStatusProc(self, event):

self.UpdateMethodsFromPLCStatus()

if connector is not None:

if self.StatusTimer is not None:

# Start the status Timer

else:

if self.StatusTimer is not None:

# Stop the status Timer

self.logger.write(_("Transfer completed successfully.\n"))

else:

self.logger.write_error(_("Transfer failed\n"))

else:

self.logger.write_error(_("No PLC to transfer (did build succeed ?)\n"))

#!/usr/bin/env python

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

#

#

#

#

#

from types import *

# Check Id is in slave node list

if nodeid not in self.NodeList.SlaveNodes.keys():

# Get the model for this node (made from EDS)

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

# Extract and check index and subindex

if not node.IsEntry(index, subindex):

# Get the entry info

subentry_infos = node.GetSubentryInfos(index, subindex)

if sizelocation == "X" and len(loc) > 3:

numbit = loc[3]

elif sizelocation != "X" and len(loc) > 3:

else:

numbit = None

if location["IEC_TYPE"] != "BOOL" and subentry_infos["type"] != COlocationtype:

typeinfos = node.GetEntryInfos(COlocationtype)

self.IECLocations[name] = {"type":COlocationtype, "pdotype":SlavePDOType[direction],

"nodeid": nodeid, "index": index,"subindex": subindex,

"bit": numbit, "size": typeinfos["size"], "sizelocation": sizelocation}

else:

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

# Search for locations already mapped

# Extract and check index and subindex

if not slave.IsEntry(index, subindex):

# Get the entry info

subentry_infos = slave.GetSubentryInfos(index, subindex)

if subentry_infos["type"] != COlocationtype:

IECLocations[name] = COlocationtype

pointers[(index, subindex)] = name

#!/usr/bin/env python

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

#

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

#

# See COPYING file for copyrights details.

#

#

# but WITHOUT ANY WARRANTY; without even the implied warranty of

#

import Pyro

import Pyro.core

import Pyro.util

ip = str(socket.inet_ntoa(i.getAddress()))

port = str(i.getPort())

newlocation = ip + ':' + port

location = newlocation

r.close()

except Exception, msg:

try:

return func(*args, **kwargs)

except Pyro.errors.ConnectionClosedError, e:

confnodesroot._SetConnector(None)

except Pyro.errors.ProtocolError, e:

except Exception, e:

# confnodesroot.logger.write_error(traceback.format_exc())

errmess = ''.join(Pyro.util.getPyroTraceback(e))

#!/usr/bin/env python

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

#

#

#

#

#

import sys, traceback, atexit

#from twisted.python import log

reactor, _WampSession.call, wampfuncname,

*args,**kwargs)

except TransportLost, e:

confnodesroot._SetConnector(None)

except Exception,e:

errmess = traceback.format_exc()

#!/usr/bin/env python

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

#

# Copyright (C) 2007: Edouard TISSERANT and Laurent BESSARD

#

# See COPYING file for copyrights details.

#

#

# but WITHOUT ANY WARRANTY; without even the implied warranty of

#

# Package initialisation

#!/usr/bin/env python

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

#

#

#

#

#

import wx

import wx.gizmos

#!/usr/bin/env python

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

#

#

#

#

#

import wx

import wx.grid

self.UpButton = None

self.DownButton = None

self.SetSelectionBackground(wx.WHITE)

self.SetSelectionForeground(wx.BLACK)

self.DisableDragRowSize()

#!/usr/bin/env python

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