beremiz: comparison plugger.py

equal deleted inserted replaced

-:32339ad7d9ae
+:331d698e1118
 XMLFile.close()
 # Call the plugin specific OnPlugSave method
 result = self.OnPlugSave()
 if not result:
-return "Error while saving \"%s\"\n"%self.PlugPath()
+return _("Error while saving \"%s\"\n")%self.PlugPath()
 # mark plugin as saved
 self.ChangesToSave = False
 # go through all childs and do the same
 for PlugChild in self.IterChilds():
 # Generate plugins [(Cfiles, CFLAGS)], LDFLAGS, DoCalls, extra_files
 # extra_files = [(fname,fobject), ...]
 gen_result = self.PlugGenerate_C(buildpath, locations)
 PlugCFilesAndCFLAGS, PlugLDFLAGS, DoCalls = gen_result[:3]
 extra_files = gen_result[3:]
-# if some files heve been generated put them in the list with their location
+# if some files have been generated put them in the list with their location
 if PlugCFilesAndCFLAGS:
 LocationCFilesAndCFLAGS = [(self.GetCurrentLocation(), PlugCFilesAndCFLAGS, DoCalls)]
 else:
 LocationCFilesAndCFLAGS = []
 # Rename plugin dir if exist
 if not dontexist:
 shutil.move(oldname, self.PlugPath())
 # warn user he has two left hands
 if DesiredName != res:
-self.logger.write_warning("A child names \"%s\" already exist -> \"%s\"\n"%(DesiredName,res))
+self.logger.write_warning(_("A child names \"%s\" already exist -> \"%s\"\n")%(DesiredName,res))
 return res
 def FindNewIEC_Channel(self, DesiredChannel):
 """
 Changes IEC Channel number to DesiredChannel if available, nearest available if not.
 res = DesiredChannel
 while res in AllChannels: # While channel not free
 if res < CurrentChannel: # Want to go down ?
 res -=  1 # Test for n-1
 if res < 0 :
-self.logger.write_warning("Cannot find lower free IEC channel than %d\n"%CurrentChannel)
+self.logger.write_warning(_("Cannot find lower free IEC channel than %d\n")%CurrentChannel)
 return CurrentChannel # Can't go bellow 0, do nothing
 else : # Want to go up ?
 res +=  1 # Test for n-1
 # Finally set IEC Channel
 self.BaseParams.setIEC_Channel(res)
 if DesiredChannel != res:
-self.logger.write_warning("A child with IEC channel %d already exist -> %d\n"%(DesiredChannel,res))
+self.logger.write_warning(_("A child with IEC channel %d already exist -> %d\n")%(DesiredChannel,res))
 return res
 def OnPlugClose(self):
 return True
 PlugChildsTypes = dict(zip(transpose[0],zip(transpose[1],transpose[2])))
 # Check that adding this plugin is allowed
 try:
 PlugClass, PlugHelp = PlugChildsTypes[PlugType]
 except KeyError:
-raise Exception, "Cannot create child %s of type %s "%(PlugName, PlugType)
+raise Exception, _("Cannot create child %s of type %s ")%(PlugName, PlugType)
 # if PlugClass is a class factory, call it. (prevent unneeded imports)
 if type(PlugClass) == types.FunctionType:
 PlugClass = PlugClass()
 # Eventualy Initialize child instance list for this class of plugin
 PluggedChildsWithSameClass = self.PluggedChilds.setdefault(PlugType, list())
 # Check count
 if getattr(PlugClass, "PlugMaxCount", None) and len(PluggedChildsWithSameClass) >= PlugClass.PlugMaxCount:
-raise Exception, "Max count (%d) reached for this plugin of type %s "%(PlugClass.PlugMaxCount, PlugType)
+raise Exception, _("Max count (%d) reached for this plugin of type %s ")%(PlugClass.PlugMaxCount, PlugType)
 # create the final class, derived of provided plugin and template
 class FinalPlugClass(PlugClass, PlugTemplate):
 """
 Plugin class is derivated into FinalPlugClass before being instanciated
 if os.path.isdir(_self.PlugPath(NewPlugName)): #and os.path.isfile(_self.PluginXmlFilePath(PlugName)):
 #Load the plugin.xml file into parameters members
 _self.LoadXMLParams(NewPlugName)
 # Basic check. Better to fail immediately.
 if (_self.BaseParams.getName() != NewPlugName):
-raise Exception, "Project tree layout do not match plugin.xml %s!=%s "%(NewPlugName, _self.BaseParams.getName())
+raise Exception, _("Project tree layout do not match plugin.xml %s!=%s ")%(NewPlugName, _self.BaseParams.getName())
 # Now, self.PlugPath() should be OK
 # Check that IEC_Channel is not already in use.
 _self.FindNewIEC_Channel(_self.BaseParams.getIEC_Channel())
 basexmlfile = open(self.PluginBaseXmlFilePath(PlugName), 'r')
 basetree = minidom.parse(basexmlfile)
 self.MandatoryParams[1].loadXMLTree(basetree.childNodes[0])
 basexmlfile.close()
 except Exception, exc:
-self.logger.write_error("Couldn't load plugin base parameters %s :\n %s" % (PlugName, str(exc)))
+self.logger.write_error(_("Couldn't load plugin base parameters %s :\n %s") % (PlugName, str(exc)))
 self.logger.write_error(traceback.format_exc())
 # Get the xml tree
 if self.PlugParams:
 try:
 xmlfile = open(self.PluginXmlFilePath(PlugName), 'r')
 tree = minidom.parse(xmlfile)
 self.PlugParams[1].loadXMLTree(tree.childNodes[0])
 xmlfile.close()
 except Exception, exc:
-self.logger.write_error("Couldn't load plugin parameters %s :\n %s" % (PlugName, str(exc)))
+self.logger.write_error(_("Couldn't load plugin parameters %s :\n %s") % (PlugName, str(exc)))
 self.logger.write_error(traceback.format_exc())
 def LoadChilds(self):
 # Iterate over all PlugName@PlugType in plugin directory, and try to open them
 for PlugDir in os.listdir(self.PlugPath()):
 PlugDir.count(NameTypeSeparator) == 1:
 pname, ptype = PlugDir.split(NameTypeSeparator)
 try:
 self.PlugAddChild(pname, ptype)
 except Exception, exc:
-self.logger.write_error("Could not add child \"%s\", type %s :\n%s\n"%(pname, ptype, str(exc)))
+self.logger.write_error(_("Could not add child \"%s\", type %s :\n%s\n")%(pname, ptype, str(exc)))
 self.logger.write_error(traceback.format_exc())
 def EnableMethod(self, method, value):
 for d in self.PluginMethods:
 if d["method"]==method:
 @param ProjectPath: path of the folder where project have to be created
 @param PLCParams: properties of the PLCOpen program created
 """
 # Verify that choosen folder is empty
 if not os.path.isdir(ProjectPath) or len(os.listdir(ProjectPath)) > 0:
-return "Folder choosen isn't empty. You can't use it for a new project!"
+return _("Folder choosen isn't empty. You can't use it for a new project!")
 dialog = ProjectDialog(self.AppFrame)
 if dialog.ShowModal() == wx.ID_OK:
 values = dialog.GetValues()
 values["creationDateTime"] = datetime(*localtime()[:6])
 dialog.Destroy()
 else:
 dialog.Destroy()
-return "Project not created"
+return _("Project not created")
 # Create PLCOpen program
 self.CreateNewProject(values)
 # Change XSD into class members
 self._AddParamsMembers()
 if os.path.basename(ProjectPath) == "":
 ProjectPath = os.path.dirname(ProjectPath)
 		# Verify that project contains a PLCOpen program
 plc_file = os.path.join(ProjectPath, "plc.xml")
 if not os.path.isfile(plc_file):
-return "Folder choosen doesn't contain a program. It's not a valid project!"
+return _("Folder choosen doesn't contain a program. It's not a valid project!")
 # Load PLCOpen file
 result = self.OpenXMLFile(plc_file)
 if result:
 return result
 # Change XSD into class members
 """
 # Update PLCOpenEditor Plugin Block types before generate ST code
 self.RefreshPluginsBlockLists()
-self.logger.write("Generating SoftPLC IEC-61131 ST/IL/SFC code...\n")
+self.logger.write(_("Generating SoftPLC IEC-61131 ST/IL/SFC code...\n"))
 buildpath = self._getBuildPath()
 # ask PLCOpenEditor controller to write ST/IL/SFC code file
 program, errors, warnings = self.GenerateProgram(self._getIECgeneratedcodepath())
 if len(warnings) > 0:
-self.logger.write_warning("Warnings in ST/IL/SFC code generator :\n")
+self.logger.write_warning(_("Warnings in ST/IL/SFC code generator :\n"))
 for warning in warnings:
 self.logger.write_warning("%s\n"%warning)
 if len(errors) > 0:
 # Failed !
-self.logger.write_error("Error in ST/IL/SFC code generator :\n%s\n"%errors[0])
+self.logger.write_error(_("Error in ST/IL/SFC code generator :\n%s\n")%errors[0])
 return False
 plc_file = open(self._getIECcodepath(), "w")
 if getattr(self, "PluggedChilds", None) is not None:
 # Add ST Library from plugins
 plc_file.write(self.STLibraryFactory())
 self.ProgramOffset += 1
 plc_file.close()
 plc_file = open(self._getIECcodepath(), "a")
 plc_file.write(open(self._getIECgeneratedcodepath(), "r").read())
 plc_file.close()
-self.logger.write("Compiling IEC Program in to C code...\n")
+self.logger.write(_("Compiling IEC Program in to C code...\n"))
 # Now compile IEC code into many C files
 # files are listed to stdout, and errors to stderr.
 status, result, err_result = ProcessLogger(
 self.logger,
 "\"%s\" -f -I \"%s\" -T \"%s\" \"%s\""%(
 last_section = None # only write section once
 self.logger.write_warning("%04d: %s" % (i, line))
 f.close()
-self.logger.write_error("Error : IEC to C compiler returned %d\n"%status)
+self.logger.write_error(_("Error : IEC to C compiler returned %d\n")%status)
 return False
 # Now extract C files of stdout
 C_files = [ fname for fname in result.splitlines() if fname[-2:]==".c" or fname[-2:]==".C" ]
 # remove those that are not to be compiled because included by others
 C_files.remove("POUS.c")
 if not C_files:
-self.logger.write_error("Error : At least one configuration and one ressource must be declared in PLC !\n")
+self.logger.write_error(_("Error : At least one configuration and one ressource must be declared in PLC !\n"))
 return False
 # transform those base names to full names with path
 C_files = map(lambda filename:os.path.join(buildpath, filename), C_files)
-self.logger.write("Extracting Located Variables...\n")
+self.logger.write(_("Extracting Located Variables...\n"))
 # Keep track of generated located variables for later use by self._Generate_C
 self.PLCGeneratedLocatedVars = self.GetLocations()
 # Keep track of generated C files for later use by self.PlugGenerate_C
 self.PLCGeneratedCFiles = C_files
 # compute CFLAGS for plc
 # Get module reference
 try :
 targetmodule = getattr(__import__(modulename), targetname)
 except Exception, msg:
-self.logger.write_error("Can't find module for target %s!\n"%targetname)
+self.logger.write_error(_("Can't find module for target %s!\n")%targetname)
 self.logger.write_error(str(msg))
 return None
 # Get target class
 targetclass = getattr(targetmodule, classname)
 # Fill in IEC<->C translation dicts
 IEC_path=attrs["IEC_path"]
 Idx=int(attrs["num"])
 self._IECPathToIdx[IEC_path]=Idx
 except Exception,e:
-self.logger.write_error("Cannot open/parse VARIABLES.csv!\n")
+self.logger.write_error(_("Cannot open/parse VARIABLES.csv!\n"))
 self.logger.write_error(traceback.format_exc())
 self.ResetIECProgramsAndVariables()
 return False
 return True
 os.mkdir(buildpath)
 # There is something to clean
 self.EnableMethod("_Clean", True)
 self.logger.flush()
-self.logger.write("Start build in %s\n" % buildpath)
+self.logger.write(_("Start build in %s\n") % buildpath)
 # Generate SoftPLC IEC code
 IECGenRes = self._Generate_SoftPLC()
 self.ShowMethod("_showIECcode", True)
 # If IEC code gen fail, bail out.
 if not IECGenRes:
-self.logger.write_error("IEC-61131-3 code generation failed !\n")
+self.logger.write_error(_("IEC-61131-3 code generation failed !\n"))
 return False
 # Reset variable and program list that are parsed from
 # CSV file generated by IEC2C compiler.
 self.ResetIECProgramsAndVariables()
 # Generate C code and compilation params from plugin hierarchy
-self.logger.write("Generating plugins C code\n")
+self.logger.write(_("Generating plugins C code\n"))
 try:
 self.LocationCFilesAndCFLAGS, self.LDFLAGS, ExtraFiles = self._Generate_C(
 buildpath,
 self.PLCGeneratedLocatedVars)
 except Exception, exc:
-self.logger.write_error("Plugins code generation failed !\n")
+self.logger.write_error(_("Plugins code generation failed !\n"))
 self.logger.write_error(traceback.format_exc())
 return False
-# Get temprary directory path
+# Get temporary directory path
 extrafilespath = self._getExtraFilesPath()
 # Remove old directory
 if os.path.exists(extrafilespath):
 shutil.rmtree(extrafilespath)
 # Recreate directory
 code_path = os.path.join(buildpath,filename)
 open(code_path, "w").write(code)
 # Insert this file as first file to be compiled at root plugin
 self.LocationCFilesAndCFLAGS[0][1].insert(0,(code_path, self.plcCFLAGS))
 except Exception, exc:
-self.logger.write_error(name+" generation failed !\n")
+self.logger.write_error(name+_(" generation failed !\n"))
 self.logger.write_error(traceback.format_exc())
 return False
-self.logger.write("C code generated successfully.\n")
+self.logger.write(_("C code generated successfully.\n"))
 # Get current or fresh builder
 builder = self.GetBuilder()
 if builder is None:
-self.logger.write_error("Fatal : cannot get builder.\n")
+self.logger.write_error(_("Fatal : cannot get builder.\n"))
 return False
 # Build
 try:
 if not builder.build() :
-self.logger.write_error("C Build failed.\n")
+self.logger.write_error(_("C Build failed.\n"))
 return False
 except Exception, exc:
-self.logger.write_error("C Build crashed !\n")
+self.logger.write_error(_("C Build crashed !\n"))
 self.logger.write_error(traceback.format_exc())
 return False
 # Update GUI status about need for transfer
 self.CompareLocalAndRemotePLC()
 self.PLCEditor._onsave = _onsave
 self.PLCEditor.Show()
 def _Clean(self):
 if os.path.isdir(os.path.join(self._getBuildPath())):
-self.logger.write("Cleaning the build directory\n")
+self.logger.write(_("Cleaning the build directory\n"))
 shutil.rmtree(os.path.join(self._getBuildPath()))
 else:
-self.logger.write_error("Build directory already clean\n")
+self.logger.write_error(_("Build directory already clean\n"))
 self.ShowMethod("_showIECcode", False)
 self.EnableMethod("_Clean", False)
 # kill the builder
 self._builder = None
 self.CompareLocalAndRemotePLC()
 # TODO : use explicit status instead of boolean
 if self._connector is not None:
 status = self._connector.GetPLCstatus()
 else:
 status = "Disconnected"
+_ = lambda x : x
 for args in {
-"Started":[("_Run", False),
+_("Started"):     [("_Run", False),
 ("_Debug", False),
 ("_Stop", True)],
-"Stopped":[("_Run", True),
+_("Stopped"):     [("_Run", True),
 ("_Debug", True),
 ("_Stop", False)],
-"Empty":  [("_Run", False),
+_("Empty"):       [("_Run", False),
 ("_Debug", False),
 ("_Stop", False)],
-"Dirty":  [("_Run", True),
+_("Dirty"):       [("_Run", True),
 ("_Debug", True),
 ("_Stop", False)],
-"Broken": [("_Run", True),
+_("Broken"):      [("_Run", True),
 ("_Debug", True),
 ("_Stop", False)],
-"Disconnected":  [("_Run", False),
+_("Disconnected"):[("_Run", False),
 ("_Debug", False),
 ("_Stop", False),
 ("_Transfer", False),
 ("_Connect", True),
 ("_Disconnect", False)],
 }.get(status,[]):
 self.ShowMethod(*args)
 return status
 def PullPLCStatusProc(self, event):
 if self._connector is None:
 self.StatusTimer.Stop()
 current_status = self.UpdateMethodsFromPLCStatus()
 if current_status != self.previous_plcstate:
 self.previous_plcstate = current_status
-self.StatusPrint.get(current_status, self.logger.write)("PLC is %s\n"%current_status)
+if current_status is not None:
+status = _(current_status)
+else:
+status = ""
+self.StatusPrint.get(current_status, self.logger.write)(_("PLC is %s\n")%status)
 self.AppFrame.RefreshAll()
 def _Run(self):
 """
 Start PLC
 Idx = self._IECPathToIdx.get(IECPath,None)
 if Idx is not None:
 Idxs.append(Idx)
 self.TracedIECPath.append(IECPath)
 else:
-self.logger.write_warning("Debug : Unknown variable %s\n"%IECPath)
+self.logger.write_warning(_("Debug : Unknown variable %s\n")%IECPath)
 for IECPathToPop in IECPathsToPop:
 self.IECdebug_datas.pop(IECPathToPop)
 self._connector.SetTraceVariablesList(Idxs)
 self.IECdebug_lock.release()
 if value is not None:
 self.CallWeakcallables(IECPath, "NewValue", debug_tick, value)
 self.CallWeakcallables("__tick__", "NewDataAvailable")
 elif debug_vars is not None:
 wx.CallAfter(self.logger.write_warning,
-"Debug data not coherent %d != %d\n"%(len(debug_vars), len(self.TracedIECPath)))
+_("Debug data not coherent %d != %d\n")%(len(debug_vars), len(self.TracedIECPath)))
 elif debug_tick == -1:
 #wx.CallAfter(self.logger.write, "Debugger unavailable\n")
 pass
 else:
-wx.CallAfter(self.logger.write, "Debugger disabled\n")
+wx.CallAfter(self.logger.write, _("Debugger disabled\n"))
 self.debug_break = True
 self.IECdebug_lock.release()
 def KillDebugThread(self):
 self.debug_break = True
 self.DebugThread.join(timeout=1)
 if self.DebugThread.isAlive():
-self.logger.write_warning("Debug Thread couldn't be killed")
+self.logger.write_warning(_("Debug Thread couldn't be killed"))
 self.DebugThread = None
 def _Debug(self):
 """
 Start PLC (Debug Mode)
 """
 if self.GetIECProgramsAndVariables():
 self._connector.StartPLC(debug=True)
-self.logger.write("Starting PLC (debug mode)\n")
+self.logger.write(_("Starting PLC (debug mode)\n"))
 if self.PLCDebug is None:
 self.RefreshPluginsBlockLists()
 def _onclose():
 self.PLCDebug = None
 self.PLCDebug = PLCOpenEditor(self.AppFrame, self, debug=True)
 else:
 self.PLCDebug.ResetGraphicViewers()
 self.DebugThread = Thread(target=self.DebugThreadProc)
 self.DebugThread.start()
 else:
-self.logger.write_error("Couldn't start PLC debug !\n")
+self.logger.write_error(_("Couldn't start PLC debug !\n"))
 self.UpdateMethodsFromPLCStatus()
 #    def _Do_Test_Debug(self):
 #        # debug code
 def _Stop(self):
 """
 Stop PLC
 """
 if self.DebugThread is not None:
-self.logger.write("Stopping debug\n")
+self.logger.write(_("Stopping debug\n"))
 self.KillDebugThread()
 if not self._connector.StopPLC():
-self.logger.write_error("Couldn't stop PLC !\n")
+self.logger.write_error(_("Couldn't stop PLC !\n"))
 self.UpdateMethodsFromPLCStatus()
 def _Connect(self):
 # don't accept re-connetion is already connected
 if self._connector is not None:
-self.logger.write_error("Already connected. Please disconnect\n")
+self.logger.write_error(_("Already connected. Please disconnect\n"))
 return
 # Get connector uri
 uri = self.\
 BeremizRoot.\
 # Get connector from uri
 try:
 self._connector = connectors.ConnectorFactory(uri, self)
 except Exception, msg:
-self.logger.write_error("Exception while connecting %s!\n"%uri)
+self.logger.write_error(_("Exception while connecting %s!\n")%uri)
 self.logger.write_error(traceback.format_exc())
 # Did connection success ?
 if self._connector is None:
 # Oups.
-self.logger.write_error("Connection failed to %s!\n"%uri)
+self.logger.write_error(_("Connection failed to %s!\n")%uri)
 else:
 self.ShowMethod("_Connect", False)
 self.ShowMethod("_Disconnect", True)
 self.ShowMethod("_Transfer", True)
 self.CompareLocalAndRemotePLC()
 # Init with actual PLC status and print it
 self.previous_plcstate = self.UpdateMethodsFromPLCStatus()
-self.logger.write("PLC is %s\n"%self.previous_plcstate)
+if self.previous_plcstate is not None:
+status = _(self.previous_plcstate)
+else:
+status = ""
+self.logger.write(_("PLC is %s\n")%status)
 # Start the status Timer
 self.StatusTimer.Start(milliseconds=500, oneShot=False)
 def CompareLocalAndRemotePLC(self):
 MD5 = self.GetLastBuildMD5()
 # Check remote target PLC correspondance to that md5
 if MD5 is not None:
 if not self._connector.MatchMD5(MD5):
 self.logger.write_warning(
-"Latest build do not match with target, please transfer.\n")
+_("Latest build do not match with target, please transfer.\n"))
 self.EnableMethod("_Transfer", True)
 else:
 self.logger.write(
-"Latest build match target, no transfer needed.\n")
+_("Latest build match target, no transfer needed.\n"))
 self.EnableMethod("_Transfer", True)
 #self.EnableMethod("_Transfer", False)
 else:
 self.logger.write_warning(
-"Cannot compare latest build to target. Please build.\n")
+_("Cannot compare latest build to target. Please build.\n"))
 self.EnableMethod("_Transfer", False)
 def _Disconnect(self):
 self._connector = None
 # Get the last build PLC's
 MD5 = self.GetLastBuildMD5()
 # Check if md5 file is empty : ask user to build PLC
 if MD5 is None :
-self.logger.write_error("Failed : Must build before transfer.\n")
+self.logger.write_error(_("Failed : Must build before transfer.\n"))
 return False
 # Compare PLC project with PLC on target
 if self._connector.MatchMD5(MD5):
 self.logger.write(
-"Latest build already match current target. Transfering anyway...\n")
+_("Latest build already match current target. Transfering anyway...\n"))
 # Get temprary directory path
 extrafilespath = self._getExtraFilesPath()
 extrafiles = [(name, open(os.path.join(extrafilespath, name),
 'rb').read()) \
 if self.PLCDebug is not None:
 self.PLCDebug.Close()
 self.PLCDebug = None
 self.UnsubscribeAllDebugIECVariable()
 self.ProgramTransferred()
-self.logger.write("Transfer completed successfully.\n")
+self.logger.write(_("Transfer completed successfully.\n"))
 else:
-self.logger.write_error("Transfer failed\n")
+self.logger.write_error(_("Transfer failed\n"))
 else:
-self.logger.write_error("No PLC to transfer (did build success ?)\n")
+self.logger.write_error(_("No PLC to transfer (did build success ?)\n"))
 self.UpdateMethodsFromPLCStatus()
 PluginMethods = [
 {"bitmap" : opjimg("editPLC"),
-"name" : "Edit PLC",
+"name" : _("Edit PLC"),
-"tooltip" : "Edit PLC program with PLCOpenEditor",
+"tooltip" : _("Edit PLC program with PLCOpenEditor"),
 "method" : "_EditPLC"},
 {"bitmap" : opjimg("Build"),
-"name" : "Build",
+"name" : _("Build"),
-"tooltip" : "Build project into build folder",
+"tooltip" : _("Build project into build folder"),
 "method" : "_build"},
 {"bitmap" : opjimg("Clean"),
-"name" : "Clean",
+"name" : _("Clean"),
 "enabled" : False,
-"tooltip" : "Clean project build folder",
+"tooltip" : _("Clean project build folder"),
 "method" : "_Clean"},
 {"bitmap" : opjimg("Run"),
-"name" : "Run",
+"name" : _("Run"),
 "shown" : False,
-"tooltip" : "Start PLC",
+"tooltip" : _("Start PLC"),
 "method" : "_Run"},
 {"bitmap" : opjimg("Debug"),
-"name" : "Debug",
+"name" : _("Debug"),
 "shown" : False,
-"tooltip" : "Start PLC (debug mode)",
+"tooltip" : _("Start PLC (debug mode)"),
 "method" : "_Debug"},
 #        {"bitmap" : opjimg("Debug"),
 #         "name" : "Do_Test_Debug",
 #         "tooltip" : "Test debug mode)",
 #         "method" : "_Do_Test_Debug"},
 {"bitmap" : opjimg("Stop"),
-"name" : "Stop",
+"name" : _("Stop"),
 "shown" : False,
-"tooltip" : "Stop Running PLC",
+"tooltip" : _("Stop Running PLC"),
 "method" : "_Stop"},
 {"bitmap" : opjimg("Connect"),
-"name" : "Connect",
+"name" : _("Connect"),
-"tooltip" : "Connect to the target PLC",
+"tooltip" : _("Connect to the target PLC"),
 "method" : "_Connect"},
 {"bitmap" : opjimg("Transfer"),
-"name" : "Transfer",
+"name" : _("Transfer"),
 "shown" : False,
-"tooltip" : "Transfer PLC",
+"tooltip" : _("Transfer PLC"),
 "method" : "_Transfer"},
 {"bitmap" : opjimg("Disconnect"),
-"name" : "Disconnect",
+"name" : _("Disconnect"),
 "shown" : False,
-"tooltip" : "Disconnect from PLC",
+"tooltip" : _("Disconnect from PLC"),
 "method" : "_Disconnect"},
 {"bitmap" : opjimg("ShowIECcode"),
-"name" : "Show code",
+"name" : _("Show code"),
 "shown" : False,
-"tooltip" : "Show IEC code generated by PLCGenerator",
+"tooltip" : _("Show IEC code generated by PLCGenerator"),
 "method" : "_showIECcode"},
 {"bitmap" : opjimg("editIECrawcode"),
-"name" : "Raw IEC code",
+"name" : _("Raw IEC code"),
-"tooltip" : "Edit raw IEC code added to code generated by PLCGenerator",
+"tooltip" : _("Edit raw IEC code added to code generated by PLCGenerator"),
 "method" : "_editIECrawcode"},
 {"bitmap" : opjimg("editPYTHONcode"),
 "name" : "Python code",
 "tooltip" : "Write Python runtime code, for use with python_eval FBs",
 "method" : "_editPYTHONcode"},

changeset 361	331d698e1118
parent 356	e9698d0ee5f3
child 363	e0c4d3549369