- made showing a shape when hovering over objects, optional, by adding a Preferences -> General parameter

- starting to work in internationalization using gettext()
- Finished adding _() in FlatCAM Tools

FlatCAMApp.py

@@ -15,6 +15,7 @@ import random
 import logging
 import simplejson as json
 import lzma
+import gettext
 
 import re
 import os
@@ -44,6 +45,8 @@ from PlotCanvas import *
 from FlatCAMGUI import *
 from FlatCAMCommon import LoudDict
 from FlatCAMPostProc import load_postprocessors
+from FlatCAMTranslation import *
+
 from FlatCAMEditor import FlatCAMGeoEditor, FlatCAMExcEditor
 from FlatCAMProcess import *
 from FlatCAMWorkerStack import WorkerStack
@@ -275,6 +278,10 @@ class App(QtCore.QObject):
         self.FC_light_blue = '#a5a5ffbf'
         self.FC_dark_blue = '#0000ffbf'
 
+        # needs to install the app default language before the GUI is initialized otherwise we get errors
+        # because FlatCAM will not understand the _() funtion
+        self.on_language_apply(lang='English')
+
         QtCore.QObject.__init__(self)
         self.ui = FlatCAMGUI(self.version, self.beta, self)
 
@@ -302,20 +309,29 @@ class App(QtCore.QObject):
         self.defaults_form_fields = {
             # General App
             "units": self.ui.general_defaults_form.general_app_group.units_radio,
+            "global_app_level": self.ui.general_defaults_form.general_app_group.app_level_radio,
+            "global_language": self.ui.general_defaults_form.general_app_group.language_cb,
+
             "global_shell_at_startup": self.ui.general_defaults_form.general_app_group.shell_startup_cb,
             "global_version_check": self.ui.general_defaults_form.general_app_group.version_check_cb,
             "global_send_stats": self.ui.general_defaults_form.general_app_group.send_stats_cb,
+            "global_pan_button": self.ui.general_defaults_form.general_app_group.pan_button_radio,
+            "global_mselect_key": self.ui.general_defaults_form.general_app_group.mselect_radio,
+
             "global_project_at_startup": self.ui.general_defaults_form.general_app_group.project_startup_cb,
             "global_project_autohide": self.ui.general_defaults_form.general_app_group.project_autohide_cb,
-            "global_app_level": self.ui.general_defaults_form.general_app_group.app_level_radio,
+            "global_toggle_tooltips": self.ui.general_defaults_form.general_app_group.toggle_tooltips_cb,
+
             "global_compression_level": self.ui.general_defaults_form.general_app_group.compress_combo,
             "global_save_compressed": self.ui.general_defaults_form.general_app_group.save_type_cb,
-            "global_toggle_tooltips": self.ui.general_defaults_form.general_app_group.toggle_tooltips_cb,
 
-            # General GUI
+            # General GUI Preferences
             "global_gridx": self.ui.general_defaults_form.general_gui_group.gridx_entry,
             "global_gridy": self.ui.general_defaults_form.general_gui_group.gridy_entry,
             "global_snap_max": self.ui.general_defaults_form.general_gui_group.snap_max_dist_entry,
+            "global_workspace": self.ui.general_defaults_form.general_gui_group.workspace_cb,
+            "global_workspaceT": self.ui.general_defaults_form.general_gui_group.wk_cb,
+
             "global_plot_fill": self.ui.general_defaults_form.general_gui_group.pf_color_entry,
             "global_plot_line": self.ui.general_defaults_form.general_gui_group.pl_color_entry,
             "global_sel_fill": self.ui.general_defaults_form.general_gui_group.sf_color_entry,
@@ -324,11 +340,9 @@ class App(QtCore.QObject):
             "global_alt_sel_line": self.ui.general_defaults_form.general_gui_group.alt_sl_color_entry,
             "global_draw_color": self.ui.general_defaults_form.general_gui_group.draw_color_entry,
             "global_sel_draw_color": self.ui.general_defaults_form.general_gui_group.sel_draw_color_entry,
-            "global_pan_button": self.ui.general_defaults_form.general_app_group.pan_button_radio,
-            "global_mselect_key": self.ui.general_defaults_form.general_app_group.mselect_radio,
-            # "global_pan_with_space_key": self.ui.general_defaults_form.general_gui_group.pan_with_space_cb,
-            "global_workspace": self.ui.general_defaults_form.general_gui_group.workspace_cb,
-            "global_workspaceT": self.ui.general_defaults_form.general_gui_group.wk_cb,
+
+            # General GUI Settings
+            "global_hover": self.ui.general_defaults_form.general_gui_set_group.hover_cb,
 
             # Gerber General
             "gerber_plot": self.ui.gerber_defaults_form.gerber_gen_group.plot_cb,
@@ -549,21 +563,40 @@ class App(QtCore.QObject):
 
             self.ui.excellon_defaults_form.excellon_opt_group.pp_excellon_name_cb.addItem(name)
 
+        #############################
+        #### LOAD LANGUAGES ####
+        #############################
+
+        self.languages = load_languages(self)
+        for name in list(self.languages.keys()):
+            self.ui.general_defaults_form.general_app_group.language_cb.addItem(self.languages[name])
+
         self.defaults = LoudDict()
         self.defaults.set_change_callback(self.on_defaults_dict_change)  # When the dictionary changes.
         self.defaults.update({
+            # Global APP Preferences
             "global_serial": 0,
             "global_stats": {},
             "units": "IN",
+            "global_app_level": 'b',
+            "global_language": 'English',
             "global_version_check": True,
             "global_send_stats": True,
+            "global_pan_button": '2',
+            "global_mselect_key": 'Control',
             "global_project_at_startup": False,
             "global_project_autohide": True,
-            "global_app_level": 'b',
+            "global_toggle_tooltips": True,
+            "global_compression_level": 3,
+            "global_save_compressed": True,
 
+            # Global GUI Preferences
             "global_gridx": 0.0393701,
             "global_gridy": 0.0393701,
             "global_snap_max": 0.001968504,
+            "global_workspace": False,
+            "global_workspaceT": "A4P",
+
             "global_grid_context_menu": {
                 'in': [0.01, 0.02, 0.025, 0.05, 0.1],
                 'mm': [0.1, 0.2, 0.5, 1, 2.54]
@@ -577,11 +610,7 @@ class App(QtCore.QObject):
             "global_alt_sel_line": '#006E20BF',
             "global_draw_color": '#FF0000',
             "global_sel_draw_color": '#0000FF',
-            "global_pan_button": '2',
-            "global_mselect_key": 'Control',
-            # "global_pan_with_space_key": False,
-            "global_workspace": False,
-            "global_workspaceT": "A4P",
+
             "global_toolbar_view": 127,
 
             "global_background_timeout": 300000,  # Default value is 5 minutes
@@ -605,9 +634,6 @@ class App(QtCore.QObject):
             "global_shell_shape": [500, 300],  # Shape of the shell in pixels.
             "global_shell_at_startup": False,  # Show the shell at startup.
             "global_recent_limit": 10,  # Max. items in recent list.
-            "global_compression_level": 3,
-            "global_save_compressed": True,
-            "global_toggle_tooltips": True,
 
             "fit_key": 'V',
             "zoom_out_key": '-',
@@ -617,6 +643,9 @@ class App(QtCore.QObject):
             "global_point_clipboard_format": "(%.4f, %.4f)",
             "global_zdownrate": None,
 
+            # General GUI Settings
+            "global_hover": True,
+
             # Gerber General
             "gerber_plot": True,
             "gerber_solid": True,
@@ -813,6 +842,13 @@ class App(QtCore.QObject):
         if user_defaults:
             self.load_defaults(filename='current_defaults')
 
+        ############################
+        ##### APPLY APP LANGUAGE ###
+        ###########################
+
+        # apply the default language
+        self.on_language_apply()
+
         chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
         if self.defaults['global_serial'] == 0 or len(str(self.defaults['global_serial'])) < 10:
             self.defaults['global_serial'] = ''.join([random.choice(chars) for i in range(20)])
@@ -3235,12 +3271,32 @@ class App(QtCore.QObject):
             self.ui.general_defaults_form.general_app_group.units_radio.set_value("MM")
         self.on_toggle_units()
 
-    def on_language_apply(self):
+    def on_language_apply(self, lang=None):
+        """
+        Using instructions from here:
+        https://inventwithpython.com/blog/2014/12/20/translate-your-python-3-program-with-the-gettext-module/
+
+        :return:
+        """
         self.report_usage("on_language_apply()")
 
-        # TODO: apply the language
-        # app restart section
-        pass
+        name = ''
+
+        if lang is None:
+            name = self.ui.general_defaults_form.general_app_group.language_cb.currentText()
+        else:
+            name = lang
+
+        for lang_code, lang_usable in self.languages.items():
+            if lang_usable == name:
+                # break and then use the current key as language
+                break
+
+        try:
+            lang = gettext.translation('fc', localedir=str(languages_dir(self)), languages=[lang_code])
+            lang.install()
+        except Exception as e:
+            log.debug("App.on_language_apply() --> %s" % str(e))
 
     def on_fullscreen(self):
         self.report_usage("on_fullscreen()")
@@ -4733,34 +4789,36 @@ class App(QtCore.QObject):
                         self.draw_moving_selection_shape(self.pos, pos)
                         self.selection_type = True
 
-                # hover effect
-                for obj in self.collection.get_list():
-                    try:
-                        # select the object(s) only if it is enabled (plotted)
-                        if obj.options['plot']:
-                            if obj not in self.collection.get_selected():
-                                poly_obj = Polygon(
-                                    [(obj.options['xmin'], obj.options['ymin']),
-                                     (obj.options['xmax'], obj.options['ymin']),
-                                     (obj.options['xmax'], obj.options['ymax']),
-                                     (obj.options['xmin'], obj.options['ymax'])]
-                                )
-                                if Point(pos).within(poly_obj):
-                                    if obj.isHovering is False:
-                                        obj.isHovering = True
-                                        obj.notHovering = True
-                                        # create the selection box around the selected object
-                                        self.draw_hover_shape(obj, color='#d1e0e0')
-                                else:
-                                    if obj.notHovering is True:
-                                        obj.notHovering = False
-                                        obj.isHovering = False
-                                        self.delete_hover_shape()
-                    except:
-                        # the Exception here will happen if we try to select on screen and we have an newly (and empty)
-                        # just created Geometry or Excellon object that do not have the xmin, xmax, ymin, ymax options.
-                        # In this case poly_obj creation (see above) will fail
-                        pass
+                # hover effect - enabled in Preferences -> General -> GUI Settings
+                if self.defaults['global_hover']:
+                    for obj in self.collection.get_list():
+                        try:
+                            # select the object(s) only if it is enabled (plotted)
+                            if obj.options['plot']:
+                                if obj not in self.collection.get_selected():
+                                    poly_obj = Polygon(
+                                        [(obj.options['xmin'], obj.options['ymin']),
+                                         (obj.options['xmax'], obj.options['ymin']),
+                                         (obj.options['xmax'], obj.options['ymax']),
+                                         (obj.options['xmin'], obj.options['ymax'])]
+                                    )
+                                    if Point(pos).within(poly_obj):
+                                        if obj.isHovering is False:
+                                            obj.isHovering = True
+                                            obj.notHovering = True
+                                            # create the selection box around the selected object
+                                            self.draw_hover_shape(obj, color='#d1e0e0')
+                                    else:
+                                        if obj.notHovering is True:
+                                            obj.notHovering = False
+                                            obj.isHovering = False
+                                            self.delete_hover_shape()
+                        except:
+                            # the Exception here will happen if we try to select on screen and we have an
+                            # newly (and empty) just created Geometry or Excellon object that do not have the
+                            # xmin, xmax, ymin, ymax options.
+                            # In this case poly_obj creation (see above) will fail
+                            pass
 
             except:
                 self.ui.position_label.setText("")

FlatCAMGUI.py

@@ -3044,6 +3044,16 @@ class GeneralGUISetGroupUI(OptionsGroupUI):
         )
         self.clear_btn = FCButton("Clear")
         self.clear_btn.clicked.connect(self.handle_clear)
+
+        # Enable Hover box
+        self.hover_label = QtWidgets.QLabel('Hover Shape:')
+        self.hover_label.setToolTip(
+            "Enable display of a hover shape for FlatCAM objects.\n"
+            "It is displayed whenever the mouse cursor is hovering\n"
+            "over any kind of not-selected object."
+        )
+        self.hover_cb = FCCheckBox()
+
         # Just to add empty rows
         self.spacelabel = QtWidgets.QLabel('')
 
@@ -3054,6 +3064,7 @@ class GeneralGUISetGroupUI(OptionsGroupUI):
         self.form_box.addRow(self.style_label, self.style_combo)
         self.form_box.addRow(self.hdpi_label, self.hdpi_cb)
         self.form_box.addRow(self.clear_label, self.clear_btn)
+        self.form_box.addRow(self.hover_label, self.hover_cb)
 
         # Add the QFormLayout that holds the Application general defaults
         # to the main layout of this TAB

FlatCAMTranslation.py

@@ -0,0 +1,39 @@
+import os
+from datetime import datetime
+
+import FlatCAMApp
+from FlatCAMApp import log
+
+# ISO639-1 codes from here: https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes
+languages_dict = {
+    'de': 'German',
+    'en': 'English',
+    'es': 'Spanish',
+    'fr': 'French',
+    'it': 'Italian',
+    'ro': 'Romanian',
+    'ru': 'Russian',
+    'zh': 'Chinese',
+}
+
+translations = {}
+
+languages_path_search = ''
+
+
+def load_languages(app):
+    languages_path_search = os.path.join('locale')
+
+    available_translations = next(os.walk(languages_path_search))[1]
+
+    for lang in available_translations:
+        try:
+            if lang in languages_dict.keys():
+                translations[lang] = languages_dict[lang]
+        except KeyError as e:
+            log.debug("FlatCAMTranslations.load_languages() --> %s" % str(e))
+    return translations
+
+
+def languages_dir(app):
+    return os.path.join('locale')

README.md

@@ -9,12 +9,17 @@ CAD program, and create G-Code for Isolation routing.
 
 =================================================
 
+7.03.2019
+
+- made showing a shape when hovering over objects, optional, by adding a Preferences -> General parameter
+- starting to work in internationalization using gettext()
+- Finished adding _() in FlatCAM Tools
+
 6.03.2019
 
 - modified the way the FlatCAM Tools are run from toolbar as opposed of running them from other sources
 - some Gerber UI changes
 
-
 5.03.2019
 
 - modified the grbl-laser postprocessor lift_code()

flatcamTools/ToolCalculators.py

@@ -7,10 +7,10 @@ import math
 
 class ToolCalculator(FlatCAMTool):
 
-    toolName = "Calculators"
-    v_shapeName = "V-Shape Tool Calculator"
-    unitsName = "Units Calculator"
-    eplateName = "ElectroPlating Calculator"
+    toolName = _("Calculators")
+    v_shapeName = _("V-Shape Tool Calculator")
+    unitsName = _("Units Calculator")
+    eplateName = _("ElectroPlating Calculator")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
@@ -51,12 +51,12 @@ class ToolCalculator(FlatCAMTool):
         self.inch_entry = FCEntry()
         # self.inch_entry.setFixedWidth(70)
         self.inch_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.inch_entry.setToolTip("Here you enter the value to be converted from INCH to MM")
+        self.inch_entry.setToolTip(_("Here you enter the value to be converted from INCH to MM"))
 
         self.mm_entry = FCEntry()
         # self.mm_entry.setFixedWidth(130)
         self.mm_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.mm_entry.setToolTip("Here you enter the value to be converted from MM to INCH")
+        self.mm_entry.setToolTip(_("Here you enter the value to be converted from MM to INCH"))
 
         grid_units_layout.addWidget(self.mm_entry, 1, 0)
         grid_units_layout.addWidget(self.inch_entry, 1, 1)
@@ -77,34 +77,34 @@ class ToolCalculator(FlatCAMTool):
         form_layout = QtWidgets.QFormLayout()
         self.layout.addLayout(form_layout)
 
-        self.tipDia_label = QtWidgets.QLabel("Tip Diameter:")
+        self.tipDia_label = QtWidgets.QLabel(_("Tip Diameter:"))
         self.tipDia_entry = FCEntry()
         # self.tipDia_entry.setFixedWidth(70)
         self.tipDia_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.tipDia_label.setToolTip('This is the diameter of the tool tip.\n'
-                                     'The manufacturer specifies it.')
+        self.tipDia_label.setToolTip(_('This is the diameter of the tool tip.\n'
+                                     'The manufacturer specifies it.'))
 
         self.tipAngle_label = QtWidgets.QLabel("Tip Angle:")
         self.tipAngle_entry = FCEntry()
         # self.tipAngle_entry.setFixedWidth(70)
         self.tipAngle_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.tipAngle_label.setToolTip("This is the angle of the tip of the tool.\n"
-                                       "It is specified by manufacturer.")
+        self.tipAngle_label.setToolTip(_("This is the angle of the tip of the tool.\n"
+                                       "It is specified by manufacturer."))
 
         self.cutDepth_label = QtWidgets.QLabel("Cut Z:")
         self.cutDepth_entry = FCEntry()
         # self.cutDepth_entry.setFixedWidth(70)
         self.cutDepth_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.cutDepth_label.setToolTip("This is the depth to cut into the material.\n"
-                                       "In the CNCJob is the CutZ parameter.")
+        self.cutDepth_label.setToolTip(_("This is the depth to cut into the material.\n"
+                                       "In the CNCJob is the CutZ parameter."))
 
         self.effectiveToolDia_label = QtWidgets.QLabel("Tool Diameter:")
         self.effectiveToolDia_entry = FCEntry()
         # self.effectiveToolDia_entry.setFixedWidth(70)
         self.effectiveToolDia_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.effectiveToolDia_label.setToolTip("This is the tool diameter to be entered into\n"
+        self.effectiveToolDia_label.setToolTip(_("This is the tool diameter to be entered into\n"
                                                "FlatCAM Gerber section.\n"
-                                               "In the CNCJob section it is called >Tool dia<.")
+                                               "In the CNCJob section it is called >Tool dia<."))
         # self.effectiveToolDia_entry.setEnabled(False)
 
 
@@ -114,11 +114,11 @@ class ToolCalculator(FlatCAMTool):
         form_layout.addRow(self.effectiveToolDia_label, self.effectiveToolDia_entry)
 
         ## Buttons
-        self.calculate_vshape_button = QtWidgets.QPushButton("Calculate")
+        self.calculate_vshape_button = QtWidgets.QPushButton(_("Calculate"))
         # self.calculate_button.setFixedWidth(70)
         self.calculate_vshape_button.setToolTip(
-            "Calculate either the Cut Z or the effective tool diameter,\n  "
-            "depending on which is desired and which is known. "
+            _("Calculate either the Cut Z or the effective tool diameter,\n  "
+            "depending on which is desired and which is known. ")
         )
         self.empty_label = QtWidgets.QLabel(" ")
 
@@ -135,8 +135,8 @@ class ToolCalculator(FlatCAMTool):
         ## Title of the ElectroPlating Tools Calculator
         plate_title_label = QtWidgets.QLabel("<font size=3><b>%s</b></font>" % self.eplateName)
         plate_title_label.setToolTip(
-            "This calculator is useful for those who plate the via/pad/drill holes,\n"
-            "using a method like grahite ink or calcium hypophosphite ink or palladium chloride."
+            _("This calculator is useful for those who plate the via/pad/drill holes,\n"
+            "using a method like grahite ink or calcium hypophosphite ink or palladium chloride.")
         )
         self.layout.addWidget(plate_title_label)
 
@@ -144,49 +144,49 @@ class ToolCalculator(FlatCAMTool):
         plate_form_layout = QtWidgets.QFormLayout()
         self.layout.addLayout(plate_form_layout)
 
-        self.pcblengthlabel = QtWidgets.QLabel("Board Length:")
+        self.pcblengthlabel = QtWidgets.QLabel(_("Board Length:"))
         self.pcblength_entry = FCEntry()
         # self.pcblengthlabel.setFixedWidth(70)
         self.pcblength_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.pcblengthlabel.setToolTip('This is the board length. In centimeters.')
+        self.pcblengthlabel.setToolTip(_('This is the board length. In centimeters.'))
 
-        self.pcbwidthlabel = QtWidgets.QLabel("Board Width:")
+        self.pcbwidthlabel = QtWidgets.QLabel(_("Board Width:"))
         self.pcbwidth_entry = FCEntry()
         # self.pcbwidthlabel.setFixedWidth(70)
         self.pcbwidth_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.pcbwidthlabel.setToolTip('This is the board width.In centimeters.')
+        self.pcbwidthlabel.setToolTip(_('This is the board width.In centimeters.'))
 
-        self.cdensity_label = QtWidgets.QLabel("Current Density:")
+        self.cdensity_label = QtWidgets.QLabel(_("Current Density:"))
         self.cdensity_entry = FCEntry()
         # self.cdensity_entry.setFixedWidth(70)
         self.cdensity_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.cdensity_label.setToolTip("Current density to pass through the board. \n"
-                                       "In Amps per Square Feet ASF.")
+        self.cdensity_label.setToolTip(_("Current density to pass through the board. \n"
+                                       "In Amps per Square Feet ASF."))
 
 
-        self.growth_label = QtWidgets.QLabel("Copper Growth:")
+        self.growth_label = QtWidgets.QLabel(_("Copper Growth:"))
         self.growth_entry = FCEntry()
         # self.growth_entry.setFixedWidth(70)
         self.growth_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.growth_label.setToolTip("How thick the copper growth is intended to be.\n"
-                                     "In microns.")
+        self.growth_label.setToolTip(_("How thick the copper growth is intended to be.\n"
+                                     "In microns."))
 
         # self.growth_entry.setEnabled(False)
 
-        self.cvaluelabel = QtWidgets.QLabel("Current Value:")
+        self.cvaluelabel = QtWidgets.QLabel(_("Current Value:"))
         self.cvalue_entry = FCEntry()
         # self.cvaluelabel.setFixedWidth(70)
         self.cvalue_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.cvaluelabel.setToolTip('This is the current intensity value\n'
-                                     'to be set on the Power Supply. In Amps.')
+        self.cvaluelabel.setToolTip(_('This is the current intensity value\n'
+                                     'to be set on the Power Supply. In Amps.'))
         self.cvalue_entry.setDisabled(True)
 
-        self.timelabel = QtWidgets.QLabel("Time:")
+        self.timelabel = QtWidgets.QLabel(_("Time:"))
         self.time_entry = FCEntry()
         # self.timelabel.setFixedWidth(70)
         self.time_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.timelabel.setToolTip('This is the calculated time required for the procedure.\n'
-                                  'In minutes.')
+        self.timelabel.setToolTip(_('This is the calculated time required for the procedure.\n'
+                                  'In minutes.'))
         self.time_entry.setDisabled(True)
 
         plate_form_layout.addRow(self.pcblengthlabel, self.pcblength_entry)
@@ -197,11 +197,11 @@ class ToolCalculator(FlatCAMTool):
         plate_form_layout.addRow(self.timelabel, self.time_entry)
 
         ## Buttons
-        self.calculate_plate_button = QtWidgets.QPushButton("Calculate")
+        self.calculate_plate_button = QtWidgets.QPushButton(_("Calculate"))
         # self.calculate_button.setFixedWidth(70)
         self.calculate_plate_button.setToolTip(
-            "Calculate the current intensity value and the procedure time,\n  "
-            "depending on the parameters above"
+            _("Calculate the current intensity value and the procedure time,\n  "
+            "depending on the parameters above")
         )
         self.empty_label_2 = QtWidgets.QLabel(" ")
 
@@ -287,8 +287,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 tip_diameter = float(self.tipDia_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         try:
@@ -298,8 +298,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 half_tip_angle = float(self.tipAngle_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         half_tip_angle /= 2
 
@@ -310,8 +310,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 cut_depth = float(self.cutDepth_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         tool_diameter = tip_diameter + (2 * cut_depth * math.tan(math.radians(half_tip_angle)))
@@ -325,8 +325,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 mm_val = float(self.mm_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         self.inch_entry.set_value('%.6f' % (mm_val / 25.4))
 
@@ -338,8 +338,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 inch_val = float(self.inch_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         self.mm_entry.set_value('%.6f' % (inch_val * 25.4))
 
@@ -352,8 +352,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 length = float(self.pcblength_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         try:
@@ -363,8 +363,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 width = float(self.pcbwidth_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         try:
@@ -374,8 +374,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 density = float(self.cdensity_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         try:
@@ -385,8 +385,8 @@ class ToolCalculator(FlatCAMTool):
             try:
                 copper = float(self.growth_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         calculated_current = (length * width * density) * 0.0021527820833419

flatcamTools/ToolCutOut.py

@@ -3,10 +3,9 @@ from ObjectCollection import *
 from FlatCAMApp import *
 from shapely.geometry import box
 
-
 class CutOut(FlatCAMTool):
 
-    toolName = "Cutout PCB"
+    toolName = _("Cutout PCB")
     gapFinished = pyqtSignal()
 
     def __init__(self, app):
@@ -42,12 +41,12 @@ class CutOut(FlatCAMTool):
         # self.type_obj_combo.setItemIcon(1, QtGui.QIcon("share/drill16.png"))
         self.type_obj_combo.setItemIcon(2, QtGui.QIcon("share/geometry16.png"))
 
-        self.type_obj_combo_label = QtWidgets.QLabel("Obj Type:")
+        self.type_obj_combo_label = QtWidgets.QLabel(_("Obj Type:"))
         self.type_obj_combo_label.setToolTip(
-            "Specify the type of object to be cutout.\n"
+            _("Specify the type of object to be cutout.\n"
             "It can be of type: Gerber or Geometry.\n"
             "What is selected here will dictate the kind\n"
-            "of objects that will populate the 'Object' combobox."
+            "of objects that will populate the 'Object' combobox.")
         )
         self.type_obj_combo_label.setFixedWidth(60)
         form_layout.addRow(self.type_obj_combo_label, self.type_obj_combo)
@@ -58,39 +57,39 @@ class CutOut(FlatCAMTool):
         self.obj_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
         self.obj_combo.setCurrentIndex(1)
 
-        self.object_label = QtWidgets.QLabel("Object:")
+        self.object_label = QtWidgets.QLabel(_("Object:"))
         self.object_label.setToolTip(
-            "Object to be cutout.                        "
+            _("Object to be cutout.                        ")
         )
         form_layout.addRow(self.object_label, self.obj_combo)
 
         # Tool Diameter
         self.dia = FCEntry()
-        self.dia_label = QtWidgets.QLabel("Tool Dia:")
+        self.dia_label = QtWidgets.QLabel(_("Tool Dia:"))
         self.dia_label.setToolTip(
-            "Diameter of the tool used to cutout\n"
-            "the PCB shape out of the surrounding material."
+           _( "Diameter of the tool used to cutout\n"
+            "the PCB shape out of the surrounding material.")
         )
         form_layout.addRow(self.dia_label, self.dia)
 
         # Margin
         self.margin = FCEntry()
-        self.margin_label = QtWidgets.QLabel("Margin:")
+        self.margin_label = QtWidgets.QLabel(_("Margin:"))
         self.margin_label.setToolTip(
-            "Margin over bounds. A positive value here\n"
+           _( "Margin over bounds. A positive value here\n"
             "will make the cutout of the PCB further from\n"
-            "the actual PCB border"
+            "the actual PCB border")
         )
         form_layout.addRow(self.margin_label, self.margin)
 
         # Gapsize
         self.gapsize = FCEntry()
-        self.gapsize_label = QtWidgets.QLabel("Gap size:")
+        self.gapsize_label = QtWidgets.QLabel(_("Gap size:"))
         self.gapsize_label.setToolTip(
-            "The size of the bridge gaps in the cutout\n"
+           _( "The size of the bridge gaps in the cutout\n"
             "used to keep the board connected to\n"
             "the surrounding material (the one \n"
-            "from which the PCB is cutout)."
+            "from which the PCB is cutout).")
         )
         form_layout.addRow(self.gapsize_label, self.gapsize)
 
@@ -103,9 +102,9 @@ class CutOut(FlatCAMTool):
         # 8     - 2*left + 2*right +2*top + 2*bottom
 
         ## Title2
-        title_param_label = QtWidgets.QLabel("<font size=4><b>A. Automatic Bridge Gaps</b></font>")
+        title_param_label = QtWidgets.QLabel("<font size=4><b>%s</b></font>" % _('A. Automatic Bridge Gaps'))
         title_param_label.setToolTip(
-            "This section handle creation of automatic bridge gaps."
+            _("This section handle creation of automatic bridge gaps.")
         )
         self.layout.addWidget(title_param_label)
 
@@ -114,9 +113,9 @@ class CutOut(FlatCAMTool):
         self.layout.addLayout(form_layout_2)
 
         # Gaps
-        gaps_label = QtWidgets.QLabel('Gaps:')
+        gaps_label = QtWidgets.QLabel(_('Gaps:'))
         gaps_label.setToolTip(
-            "Number of gaps used for the Automatic cutout.\n"
+            _("Number of gaps used for the Automatic cutout.\n"
             "There can be maximum 8 bridges/gaps.\n"
             "The choices are:\n"
             "- lr    - left + right\n"
@@ -124,7 +123,7 @@ class CutOut(FlatCAMTool):
             "- 4     - left + right +top + bottom\n"
             "- 2lr   - 2*left + 2*right\n"
             "- 2tb  - 2*top + 2*bottom\n"
-            "- 8     - 2*left + 2*right +2*top + 2*bottom"
+            "- 8     - 2*left + 2*right +2*top + 2*bottom")
         )
         gaps_label.setFixedWidth(60)
 
@@ -139,50 +138,50 @@ class CutOut(FlatCAMTool):
         hlay = QtWidgets.QHBoxLayout()
         self.layout.addLayout(hlay)
 
-        title_ff_label = QtWidgets.QLabel("<b>FreeForm:</b>")
+        title_ff_label = QtWidgets.QLabel("<b>%s</b>" % _('FreeForm:'))
         title_ff_label.setToolTip(
-            "The cutout shape can be of ny shape.\n"
-            "Useful when the PCB has a non-rectangular shape."
+            _("The cutout shape can be of ny shape.\n"
+            "Useful when the PCB has a non-rectangular shape.")
         )
         hlay.addWidget(title_ff_label)
 
         hlay.addStretch()
 
-        self.ff_cutout_object_btn = QtWidgets.QPushButton("Generate Geo")
+        self.ff_cutout_object_btn = QtWidgets.QPushButton(_("Generate Geo"))
         self.ff_cutout_object_btn.setToolTip(
-            "Cutout the selected object.\n"
+            _("Cutout the selected object.\n"
             "The cutout shape can be of any shape.\n"
-            "Useful when the PCB has a non-rectangular shape."
+            "Useful when the PCB has a non-rectangular shape.")
         )
         hlay.addWidget(self.ff_cutout_object_btn)
 
         hlay2 = QtWidgets.QHBoxLayout()
         self.layout.addLayout(hlay2)
 
-        title_rct_label = QtWidgets.QLabel("<b>Rectangular:</b>")
+        title_rct_label = QtWidgets.QLabel("<b>%s</b>" % _('Rectangular:'))
         title_rct_label.setToolTip(
-            "The resulting cutout shape is\n"
+            _("The resulting cutout shape is\n"
             "always a rectangle shape and it will be\n"
-            "the bounding box of the Object."
+            "the bounding box of the Object.")
         )
         hlay2.addWidget(title_rct_label)
 
         hlay2.addStretch()
-        self.rect_cutout_object_btn = QtWidgets.QPushButton("Generate Geo")
+        self.rect_cutout_object_btn = QtWidgets.QPushButton(_("Generate Geo"))
         self.rect_cutout_object_btn.setToolTip(
-            "Cutout the selected object.\n"
+            _("Cutout the selected object.\n"
             "The resulting cutout shape is\n"
             "always a rectangle shape and it will be\n"
-            "the bounding box of the Object."
+            "the bounding box of the Object.")
         )
         hlay2.addWidget(self.rect_cutout_object_btn)
 
         ## Title5
-        title_manual_label = QtWidgets.QLabel("<font size=4><b>B. Manual Bridge Gaps</b></font>")
+        title_manual_label = QtWidgets.QLabel("<font size=4><b>%s</b></font>" % _('B. Manual Bridge Gaps'))
         title_manual_label.setToolTip(
-            "This section handle creation of manual bridge gaps.\n"
+            _("This section handle creation of manual bridge gaps.\n"
             "This is done by mouse clicking on the perimeter of the\n"
-            "Geometry object that is used as a cutout object. "
+            "Geometry object that is used as a cutout object. ")
         )
         self.layout.addWidget(title_manual_label)
 
@@ -196,9 +195,9 @@ class CutOut(FlatCAMTool):
         self.man_object_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
         self.man_object_combo.setCurrentIndex(1)
 
-        self.man_object_label = QtWidgets.QLabel("Geo Obj:")
+        self.man_object_label = QtWidgets.QLabel(_("Geo Obj:"))
         self.man_object_label.setToolTip(
-            "Geometry object used to create the manual cutout."
+            _("Geometry object used to create the manual cutout.")
         )
         self.man_object_label.setFixedWidth(60)
         # e_lab_0 = QtWidgets.QLabel('')
@@ -209,44 +208,44 @@ class CutOut(FlatCAMTool):
         hlay3 = QtWidgets.QHBoxLayout()
         self.layout.addLayout(hlay3)
 
-        self.man_geo_label = QtWidgets.QLabel("Manual Geo:")
+        self.man_geo_label = QtWidgets.QLabel(_("Manual Geo:"))
         self.man_geo_label.setToolTip(
-            "If the object to be cutout is a Gerber\n"
+            _("If the object to be cutout is a Gerber\n"
             "first create a Geometry that surrounds it,\n"
             "to be used as the cutout, if one doesn't exist yet.\n"
-            "Select the source Gerber file in the top object combobox."
+            "Select the source Gerber file in the top object combobox.")
         )
         hlay3.addWidget(self.man_geo_label)
 
         hlay3.addStretch()
-        self.man_geo_creation_btn = QtWidgets.QPushButton("Generate Geo")
+        self.man_geo_creation_btn = QtWidgets.QPushButton(_("Generate Geo"))
         self.man_geo_creation_btn.setToolTip(
-            "If the object to be cutout is a Gerber\n"
+            _("If the object to be cutout is a Gerber\n"
             "first create a Geometry that surrounds it,\n"
             "to be used as the cutout, if one doesn't exist yet.\n"
-            "Select the source Gerber file in the top object combobox."
+            "Select the source Gerber file in the top object combobox.")
         )
         hlay3.addWidget(self.man_geo_creation_btn)
 
         hlay4 = QtWidgets.QHBoxLayout()
         self.layout.addLayout(hlay4)
 
-        self.man_bridge_gaps_label = QtWidgets.QLabel("Manual Add Bridge Gaps:")
+        self.man_bridge_gaps_label = QtWidgets.QLabel(_("Manual Add Bridge Gaps:"))
         self.man_bridge_gaps_label.setToolTip(
-            "Use the left mouse button (LMB) click\n"
+            _("Use the left mouse button (LMB) click\n"
             "to create a bridge gap to separate the PCB from\n"
-            "the surrounding material."
+            "the surrounding material.")
         )
         hlay4.addWidget(self.man_bridge_gaps_label)
 
         hlay4.addStretch()
-        self.man_gaps_creation_btn = QtWidgets.QPushButton("Generate Gap")
+        self.man_gaps_creation_btn = QtWidgets.QPushButton(_("Generate Gap"))
         self.man_gaps_creation_btn.setToolTip(
-            "Use the left mouse button (LMB) click\n"
+            _("Use the left mouse button (LMB) click\n"
             "to create a bridge gap to separate the PCB from\n"
             "the surrounding material.\n"
             "The LMB click has to be done on the perimeter of\n"
-            "the Geometry object used as a cutout geometry."
+            "the Geometry object used as a cutout geometry.")
         )
         hlay4.addWidget(self.man_gaps_creation_btn)
 
@@ -315,11 +314,11 @@ class CutOut(FlatCAMTool):
         try:
             cutout_obj = self.app.collection.get_by_name(str(name))
         except:
-            self.app.inform.emit("[ERROR_NOTCL]Could not retrieve object: %s" % name)
+            self.app.inform.emit(_("[ERROR_NOTCL]Could not retrieve object: %s") % name)
             return "Could not retrieve object: %s" % name
 
         if cutout_obj is None:
-            self.app.inform.emit("[ERROR_NOTCL]There is no object selected for Cutout.\nSelect one and try again.")
+            self.app.inform.emit(_("[ERROR_NOTCL]There is no object selected for Cutout.\nSelect one and try again."))
             return
 
         try:
@@ -329,13 +328,13 @@ class CutOut(FlatCAMTool):
             try:
                 dia = float(self.dia.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
 
         if 0 in {dia}:
-            self.app.inform.emit("[WARNING_NOTCL]Tool Diameter is zero value. Change it to a positive integer.")
+            self.app.inform.emit(_("[WARNING_NOTCL]Tool Diameter is zero value. Change it to a positive integer."))
             return "Tool Diameter is zero value. Change it to a positive integer."
 
         try:
@@ -345,8 +344,8 @@ class CutOut(FlatCAMTool):
             try:
                 margin = float(self.margin.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Margin value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Margin value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         try:
@@ -356,25 +355,25 @@ class CutOut(FlatCAMTool):
             try:
                 gapsize = float(self.gapsize.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Gap size value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Gap size value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         try:
             gaps = self.gaps.get_value()
         except TypeError:
-            self.app.inform.emit("[WARNING_NOTCL] Number of gaps value is missing. Add it and retry.")
+            self.app.inform.emit(_("[WARNING_NOTCL] Number of gaps value is missing. Add it and retry."))
             return
 
         if gaps not in ['LR', 'TB', '2LR', '2TB', '4', '8']:
-            self.app.inform.emit("[WARNING_NOTCL] Gaps value can be only one of: 'lr', 'tb', '2lr', '2tb', 4 or 8. "
-                                 "Fill in a correct value and retry. ")
+            self.app.inform.emit(_("[WARNING_NOTCL] Gaps value can be only one of: 'lr', 'tb', '2lr', '2tb', 4 or 8. "
+                                 "Fill in a correct value and retry. "))
             return
 
         if cutout_obj.multigeo is True:
-            self.app.inform.emit("[ERROR]Cutout operation cannot be done on a multi-geo Geometry.\n"
+            self.app.inform.emit(_("[ERROR]Cutout operation cannot be done on a multi-geo Geometry.\n"
                                  "Optionally, this Multi-geo Geometry can be converted to Single-geo Geometry,\n"
-                                 "and after that perform Cutout.")
+                                 "and after that perform Cutout."))
             return
 
         # Get min and max data for each object as we just cut rectangles across X or Y
@@ -438,7 +437,7 @@ class CutOut(FlatCAMTool):
                                ymax + gapsize)
 
         cutout_obj.plot()
-        self.app.inform.emit("[success] Any form CutOut operation finished.")
+        self.app.inform.emit(_("[success] Any form CutOut operation finished."))
         self.app.ui.notebook.setCurrentWidget(self.app.ui.project_tab)
         self.app.should_we_save = True
 
@@ -454,11 +453,11 @@ class CutOut(FlatCAMTool):
         try:
             cutout_obj = self.app.collection.get_by_name(str(name))
         except:
-            self.app.inform.emit("[ERROR_NOTCL]Could not retrieve object: %s" % name)
+            self.app.inform.emit(_("[ERROR_NOTCL]Could not retrieve object: %s") % name)
             return "Could not retrieve object: %s" % name
 
         if cutout_obj is None:
-            self.app.inform.emit("[ERROR_NOTCL]Object not found: %s" % cutout_obj)
+            self.app.inform.emit(_("[ERROR_NOTCL]Object not found: %s") % cutout_obj)
 
         try:
             dia = float(self.dia.get_value())
@@ -467,12 +466,12 @@ class CutOut(FlatCAMTool):
             try:
                 dia = float(self.dia.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         if 0 in {dia}:
-            self.app.inform.emit("[ERROR_NOTCL]Tool Diameter is zero value. Change it to a positive integer.")
+            self.app.inform.emit(_("[ERROR_NOTCL]Tool Diameter is zero value. Change it to a positive integer."))
             return "Tool Diameter is zero value. Change it to a positive integer."
 
         try:
@@ -482,8 +481,8 @@ class CutOut(FlatCAMTool):
             try:
                 margin = float(self.margin.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Margin value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Margin value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         try:
@@ -493,25 +492,25 @@ class CutOut(FlatCAMTool):
             try:
                 gapsize = float(self.gapsize.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Gap size value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Gap size value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         try:
             gaps = self.gaps.get_value()
         except TypeError:
-            self.app.inform.emit("[WARNING_NOTCL] Number of gaps value is missing. Add it and retry.")
+            self.app.inform.emit(_("[WARNING_NOTCL] Number of gaps value is missing. Add it and retry."))
             return
 
         if gaps not in ['LR', 'TB', '2LR', '2TB', '4', '8']:
-            self.app.inform.emit("[WARNING_NOTCL] Gaps value can be only one of: 'lr', 'tb', '2lr', '2tb', 4 or 8. "
-                                 "Fill in a correct value and retry. ")
+            self.app.inform.emit(_("[WARNING_NOTCL] Gaps value can be only one of: 'lr', 'tb', '2lr', '2tb', 4 or 8. "
+                                 "Fill in a correct value and retry. "))
             return
 
         if cutout_obj.multigeo is True:
-            self.app.inform.emit("[ERROR]Cutout operation cannot be done on a multi-geo Geometry.\n"
+            self.app.inform.emit(_("[ERROR]Cutout operation cannot be done on a multi-geo Geometry.\n"
                                  "Optionally, this Multi-geo Geometry can be converted to Single-geo Geometry,\n"
-                                 "and after that perform Cutout.")
+                                 "and after that perform Cutout."))
             return
 
         # Get min and max data for each object as we just cut rectangles across X or Y
@@ -572,12 +571,12 @@ class CutOut(FlatCAMTool):
                                ymax + gapsize)
 
         cutout_obj.plot()
-        self.app.inform.emit("[success] Any form CutOut operation finished.")
+        self.app.inform.emit(_("[success] Any form CutOut operation finished."))
         self.app.ui.notebook.setCurrentWidget(self.app.ui.project_tab)
         self.app.should_we_save = True
 
     def on_manual_gap_click(self):
-        self.app.inform.emit("Click on the selected geometry object perimeter to create a bridge gap ...")
+        self.app.inform.emit(_("Click on the selected geometry object perimeter to create a bridge gap ..."))
         self.app.geo_editor.tool_shape.enabled = True
 
         try:
@@ -587,12 +586,12 @@ class CutOut(FlatCAMTool):
             try:
                 self.cutting_dia = float(self.dia.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         if 0 in {self.cutting_dia}:
-            self.app.inform.emit("[ERROR_NOTCL]Tool Diameter is zero value. Change it to a positive integer.")
+            self.app.inform.emit(_("[ERROR_NOTCL]Tool Diameter is zero value. Change it to a positive integer."))
             return "Tool Diameter is zero value. Change it to a positive integer."
 
         try:
@@ -602,8 +601,8 @@ class CutOut(FlatCAMTool):
             try:
                 self.cutting_gapsize = float(self.gapsize.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Gap size value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Gap size value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         self.app.plotcanvas.vis_disconnect('key_press', self.app.ui.keyPressEvent)
@@ -618,7 +617,7 @@ class CutOut(FlatCAMTool):
     def doit(self, event):
         # do paint single only for left mouse clicks
         if event.button == 1:
-            self.app.inform.emit("Making manual bridge gap...")
+            self.app.inform.emit(_("Making manual bridge gap..."))
             pos = self.app.plotcanvas.vispy_canvas.translate_coords(event.pos)
             self.on_manual_cutout(click_pos=pos)
 
@@ -641,11 +640,11 @@ class CutOut(FlatCAMTool):
         try:
             cutout_obj = self.app.collection.get_by_name(str(name))
         except:
-            self.app.inform.emit("[ERROR_NOTCL]Could not retrieve Geoemtry object: %s" % name)
+            self.app.inform.emit(_("[ERROR_NOTCL]Could not retrieve Geoemtry object: %s") % name)
             return "Could not retrieve object: %s" % name
 
         if cutout_obj is None:
-            self.app.inform.emit("[ERROR_NOTCL]Geometry object for manual cutout not found: %s" % cutout_obj)
+            self.app.inform.emit(_("[ERROR_NOTCL]Geometry object for manual cutout not found: %s") % cutout_obj)
             return
 
         # use the snapped position as reference
@@ -655,7 +654,7 @@ class CutOut(FlatCAMTool):
         cutout_obj.subtract_polygon(cut_poly)
 
         cutout_obj.plot()
-        self.app.inform.emit("[success] Added manual Bridge Gap.")
+        self.app.inform.emit(_("[success] Added manual Bridge Gap."))
 
         self.app.should_we_save = True
 
@@ -672,17 +671,17 @@ class CutOut(FlatCAMTool):
         try:
             cutout_obj = self.app.collection.get_by_name(str(name))
         except:
-            self.app.inform.emit("[ERROR_NOTCL]Could not retrieve Gerber object: %s" % name)
+            self.app.inform.emit(_("[ERROR_NOTCL]Could not retrieve Gerber object: %s") % name)
             return "Could not retrieve object: %s" % name
 
         if cutout_obj is None:
-            self.app.inform.emit("[ERROR_NOTCL]There is no Gerber object selected for Cutout.\n"
-                                 "Select one and try again.")
+            self.app.inform.emit(_("[ERROR_NOTCL]There is no Gerber object selected for Cutout.\n"
+                                 "Select one and try again."))
             return
 
         if not isinstance(cutout_obj, FlatCAMGerber):
-            self.app.inform.emit("[ERROR_NOTCL]The selected object has to be of Gerber type.\n"
-                                 "Select a Gerber file and try again.")
+            self.app.inform.emit(_("[ERROR_NOTCL]The selected object has to be of Gerber type.\n"
+                                 "Select a Gerber file and try again."))
             return
 
         try:
@@ -692,12 +691,12 @@ class CutOut(FlatCAMTool):
             try:
                 dia = float(self.dia.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         if 0 in {dia}:
-            self.app.inform.emit("[ERROR_NOTCL]Tool Diameter is zero value. Change it to a positive integer.")
+            self.app.inform.emit(_("[ERROR_NOTCL]Tool Diameter is zero value. Change it to a positive integer."))
             return "Tool Diameter is zero value. Change it to a positive integer."
 
         try:
@@ -707,8 +706,8 @@ class CutOut(FlatCAMTool):
             try:
                 margin = float(self.margin.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Margin value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Margin value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         def geo_init(geo_obj, app_obj):

flatcamTools/ToolDblSided.py

@@ -9,7 +9,7 @@ from PyQt5 import QtCore
 
 class DblSidedTool(FlatCAMTool):
 
-    toolName = "2-Sided PCB"
+    toolName = _("2-Sided PCB")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
@@ -43,11 +43,11 @@ class DblSidedTool(FlatCAMTool):
             "Gerber  to be mirrored."
         )
 
-        self.mirror_gerber_button = QtWidgets.QPushButton("Mirror")
+        self.mirror_gerber_button = QtWidgets.QPushButton(_("Mirror"))
         self.mirror_gerber_button.setToolTip(
-            "Mirrors (flips) the specified object around \n"
+            _("Mirrors (flips) the specified object around \n"
             "the specified axis. Does not create a new \n"
-            "object, but modifies it."
+            "object, but modifies it.")
         )
         self.mirror_gerber_button.setFixedWidth(40)
 
@@ -64,14 +64,14 @@ class DblSidedTool(FlatCAMTool):
 
         self.excobj_label = QtWidgets.QLabel("<b>EXCELLON:</b>")
         self.excobj_label.setToolTip(
-            "Excellon Object to be mirrored."
+            _("Excellon Object to be mirrored.")
         )
 
-        self.mirror_exc_button = QtWidgets.QPushButton("Mirror")
+        self.mirror_exc_button = QtWidgets.QPushButton(_("Mirror"))
         self.mirror_exc_button.setToolTip(
-            "Mirrors (flips) the specified object around \n"
+            _("Mirrors (flips) the specified object around \n"
             "the specified axis. Does not create a new \n"
-            "object, but modifies it."
+            "object, but modifies it.")
         )
         self.mirror_exc_button.setFixedWidth(40)
 
@@ -88,14 +88,14 @@ class DblSidedTool(FlatCAMTool):
 
         self.geoobj_label = QtWidgets.QLabel("<b>GEOMETRY</b>:")
         self.geoobj_label.setToolTip(
-            "Geometry Obj to be mirrored."
+            _("Geometry Obj to be mirrored.")
         )
 
-        self.mirror_geo_button = QtWidgets.QPushButton("Mirror")
+        self.mirror_geo_button = QtWidgets.QPushButton(_("Mirror"))
         self.mirror_geo_button.setToolTip(
-            "Mirrors (flips) the specified object around \n"
+            _("Mirrors (flips) the specified object around \n"
             "the specified axis. Does not create a new \n"
-            "object, but modifies it."
+            "object, but modifies it.")
         )
         self.mirror_geo_button.setFixedWidth(40)
 
@@ -107,9 +107,9 @@ class DblSidedTool(FlatCAMTool):
         ## Axis
         self.mirror_axis = RadioSet([{'label': 'X', 'value': 'X'},
                                      {'label': 'Y', 'value': 'Y'}])
-        self.mirax_label = QtWidgets.QLabel("Mirror Axis:")
+        self.mirax_label = QtWidgets.QLabel(_("Mirror Axis:"))
         self.mirax_label.setToolTip(
-            "Mirror vertically (X) or horizontally (Y)."
+            _("Mirror vertically (X) or horizontally (Y).")
         )
         # grid_lay.addRow("Mirror Axis:", self.mirror_axis)
         self.empty_lb1 = QtWidgets.QLabel("")
@@ -120,11 +120,11 @@ class DblSidedTool(FlatCAMTool):
         ## Axis Location
         self.axis_location = RadioSet([{'label': 'Point', 'value': 'point'},
                                        {'label': 'Box', 'value': 'box'}])
-        self.axloc_label = QtWidgets.QLabel("Axis Ref:")
+        self.axloc_label = QtWidgets.QLabel(_("Axis Ref:"))
         self.axloc_label.setToolTip(
-            "The axis should pass through a <b>point</b> or cut\n "
+            _("The axis should pass through a <b>point</b> or cut\n "
             "a specified <b>box</b> (in a FlatCAM object) through \n"
-            "the center."
+            "the center.")
         )
         # grid_lay.addRow("Axis Location:", self.axis_location)
         grid_lay.addWidget(self.axloc_label, 8, 0)
@@ -135,20 +135,20 @@ class DblSidedTool(FlatCAMTool):
 
         ## Point/Box
         self.point_box_container = QtWidgets.QVBoxLayout()
-        self.pb_label = QtWidgets.QLabel("<b>Point/Box Reference:</b>")
+        self.pb_label = QtWidgets.QLabel("<b>%s</b>" % _('Point/Box Reference:'))
         self.pb_label.setToolTip(
-            "If 'Point' is selected above it store the coordinates (x, y) through which\n"
+            _("If 'Point' is selected above it store the coordinates (x, y) through which\n"
             "the mirroring axis passes.\n"
             "If 'Box' is selected above, select here a FlatCAM object (Gerber, Exc or Geo).\n"
-            "Through the center of this object pass the mirroring axis selected above."
+            "Through the center of this object pass the mirroring axis selected above.")
         )
 
-        self.add_point_button = QtWidgets.QPushButton("Add")
+        self.add_point_button = QtWidgets.QPushButton(_("Add"))
         self.add_point_button.setToolTip(
-            "Add the coordinates in format <b>(x, y)</b> through which the mirroring axis \n "
+            _("Add the coordinates in format <b>(x, y)</b> through which the mirroring axis \n "
             "selected in 'MIRROR AXIS' pass.\n"
             "The (x, y) coordinates are captured by pressing SHIFT key\n"
-            "and left mouse button click on canvas or you can enter the coords manually."
+            "and left mouse button click on canvas or you can enter the coords manually.")
         )
         self.add_point_button.setFixedWidth(40)
 
@@ -165,9 +165,9 @@ class DblSidedTool(FlatCAMTool):
         self.box_combo.setCurrentIndex(1)
 
         self.box_combo_type = QtWidgets.QComboBox()
-        self.box_combo_type.addItem("Gerber   Reference Box Object")
-        self.box_combo_type.addItem("Excellon Reference Box Object")
-        self.box_combo_type.addItem("Geometry Reference Box Object")
+        self.box_combo_type.addItem(_("Gerber   Reference Box Object"))
+        self.box_combo_type.addItem(_("Excellon Reference Box Object"))
+        self.box_combo_type.addItem(_("Geometry Reference Box Object"))
 
         self.point_box_container.addWidget(self.box_combo_type)
         self.point_box_container.addWidget(self.box_combo)
@@ -176,13 +176,13 @@ class DblSidedTool(FlatCAMTool):
 
 
         ## Alignment holes
-        self.ah_label = QtWidgets.QLabel("<b>Alignment Drill Coordinates:</b>")
+        self.ah_label = QtWidgets.QLabel("<b%s</b>" % _('>Alignment Drill Coordinates:'))
         self.ah_label.setToolTip(
-            "Alignment holes (x1, y1), (x2, y2), ... "
+           _( "Alignment holes (x1, y1), (x2, y2), ... "
             "on one side of the mirror axis. For each set of (x, y) coordinates\n"
             "entered here, a pair of drills will be created:\n\n"
             "- one drill at the coordinates from the field\n"
-            "- one drill in mirror position over the axis selected above in the 'Mirror Axis'."
+            "- one drill in mirror position over the axis selected above in the 'Mirror Axis'.")
         )
         self.layout.addWidget(self.ah_label)
 
@@ -191,15 +191,15 @@ class DblSidedTool(FlatCAMTool):
 
         self.alignment_holes = EvalEntry()
 
-        self.add_drill_point_button = QtWidgets.QPushButton("Add")
+        self.add_drill_point_button = QtWidgets.QPushButton(_("Add"))
         self.add_drill_point_button.setToolTip(
-            "Add alignment drill holes coords in the format: (x1, y1), (x2, y2), ... \n"
+            _("Add alignment drill holes coords in the format: (x1, y1), (x2, y2), ... \n"
             "on one side of the mirror axis.\n\n"
             "The coordinates set can be obtained:\n"
             "- press SHIFT key and left mouse clicking on canvas. Then click Add.\n"
             "- press SHIFT key and left mouse clicking on canvas. Then CTRL+V in the field.\n"
             "- press SHIFT key and left mouse clicking on canvas. Then RMB click in the field and click Paste.\n"
-            "- by entering the coords manually in the format: (x1, y1), (x2, y2), ..."
+            "- by entering the coords manually in the format: (x1, y1), (x2, y2), ...")
         )
         self.add_drill_point_button.setFixedWidth(40)
 
@@ -207,10 +207,10 @@ class DblSidedTool(FlatCAMTool):
         grid_lay1.addWidget(self.add_drill_point_button, 0, 3)
 
         ## Drill diameter for alignment holes
-        self.dt_label = QtWidgets.QLabel("<b>Alignment Drill Diameter</b>:")
+        self.dt_label = QtWidgets.QLabel("<b>%s</b>:" % _('Alignment Drill Diameter'))
         self.dt_label.setToolTip(
-            "Diameter of the drill for the "
-            "alignment holes."
+            _("Diameter of the drill for the "
+            "alignment holes.")
         )
         self.layout.addWidget(self.dt_label)
 
@@ -218,26 +218,28 @@ class DblSidedTool(FlatCAMTool):
         self.layout.addLayout(grid_lay2)
 
         self.drill_dia = FCEntry()
-        self.dd_label = QtWidgets.QLabel("Drill diam.:")
+        self.dd_label = QtWidgets.QLabel(_("Drill diam.:"))
         self.dd_label.setToolTip(
-            "Diameter of the drill for the "
-            "alignment holes."
+            _("Diameter of the drill for the "
+            "alignment holes.")
         )
         grid_lay2.addWidget(self.dd_label, 0, 0)
         grid_lay2.addWidget(self.drill_dia, 0, 1)
 
         ## Buttons
-        self.create_alignment_hole_button = QtWidgets.QPushButton("Create Excellon Object")
+        self.create_alignment_hole_button = QtWidgets.QPushButton(_("Create Excellon Object"))
         self.create_alignment_hole_button.setToolTip(
-            "Creates an Excellon Object containing the\n"
+            _("Creates an Excellon Object containing the\n"
             "specified alignment holes and their mirror\n"
             "images.")
+        )
         # self.create_alignment_hole_button.setFixedWidth(40)
         grid_lay2.addWidget(self.create_alignment_hole_button, 1,0, 1, 2)
 
-        self.reset_button = QtWidgets.QPushButton("Reset")
+        self.reset_button = QtWidgets.QPushButton(_("Reset"))
         self.reset_button.setToolTip(
-            "Resets all the fields.")
+            _("Resets all the fields.")
+        )
         self.reset_button.setFixedWidth(40)
         grid_lay2.addWidget(self.reset_button, 1, 2)
 
@@ -278,7 +280,7 @@ class DblSidedTool(FlatCAMTool):
         FlatCAMTool.run(self)
         self.set_tool_ui()
 
-        self.app.ui.notebook.setTabText(2, "2-Sided Tool")
+        self.app.ui.notebook.setTabText(2, _("2-Sided Tool"))
 
     def set_tool_ui(self):
         self.reset_fields()
@@ -303,8 +305,8 @@ class DblSidedTool(FlatCAMTool):
             try:
                 px, py = self.point_entry.get_value()
             except TypeError:
-                self.app.inform.emit("[WARNING_NOTCL] 'Point' reference is selected and 'Point' coordinates "
-                                     "are missing. Add them and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] 'Point' reference is selected and 'Point' coordinates "
+                                     "are missing. Add them and retry."))
                 return
         else:
             selection_index = self.box_combo.currentIndex()
@@ -322,7 +324,7 @@ class DblSidedTool(FlatCAMTool):
                         bb_obj = model_index.internalPointer().obj
                     except AttributeError:
                         self.app.inform.emit(
-                            "[WARNING_NOTCL] There is no Box reference object loaded. Load one and retry.")
+                            _("[WARNING_NOTCL] There is no Box reference object loaded. Load one and retry."))
                         return
 
             xmin, ymin, xmax, ymax = bb_obj.bounds()
@@ -339,19 +341,19 @@ class DblSidedTool(FlatCAMTool):
                 dia = float(self.drill_dia.get_value().replace(',', '.'))
                 self.drill_dia.set_value(dia)
             except ValueError:
-                self.app.inform.emit("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
-                                     "Add it and retry.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Tool diameter value is missing or wrong format. "
+                                     "Add it and retry."))
                 return
 
         if dia is '':
-            self.app.inform.emit("[WARNING_NOTCL]No value or wrong format in Drill Dia entry. Add it and retry.")
+            self.app.inform.emit(_("[WARNING_NOTCL]No value or wrong format in Drill Dia entry. Add it and retry."))
             return
         tools = {"1": {"C": dia}}
 
         # holes = self.alignment_holes.get_value()
         holes = eval('[{}]'.format(self.alignment_holes.text()))
         if not holes:
-            self.app.inform.emit("[WARNING_NOTCL] There are no Alignment Drill Coordinates to use. Add them and retry.")
+            self.app.inform.emit(_("[WARNING_NOTCL] There are no Alignment Drill Coordinates to use. Add them and retry."))
             return
 
         drills = []
@@ -373,7 +375,7 @@ class DblSidedTool(FlatCAMTool):
 
         self.app.new_object("excellon", "Alignment Drills", obj_init)
         self.drill_values = ''
-        self.app.inform.emit("[success] Excellon object with alignment drills created...")
+        self.app.inform.emit(_("[success] Excellon object with alignment drills created..."))
 
     def on_mirror_gerber(self):
         selection_index = self.gerber_object_combo.currentIndex()
@@ -382,11 +384,11 @@ class DblSidedTool(FlatCAMTool):
         try:
             fcobj = model_index.internalPointer().obj
         except Exception as e:
-            self.app.inform.emit("[WARNING_NOTCL] There is no Gerber object loaded ...")
+            self.app.inform.emit(_("[WARNING_NOTCL] There is no Gerber object loaded ..."))
             return
 
         if not isinstance(fcobj, FlatCAMGerber):
-            self.app.inform.emit("[ERROR_NOTCL] Only Gerber, Excellon and Geometry objects can be mirrored.")
+            self.app.inform.emit(_("[ERROR_NOTCL] Only Gerber, Excellon and Geometry objects can be mirrored."))
             return
 
         axis = self.mirror_axis.get_value()
@@ -396,8 +398,8 @@ class DblSidedTool(FlatCAMTool):
             try:
                 px, py = self.point_entry.get_value()
             except TypeError:
-                self.app.inform.emit("[WARNING_NOTCL] 'Point' coordinates missing. "
-                                     "Using Origin (0, 0) as mirroring reference.")
+                self.app.inform.emit(_("[WARNING_NOTCL] 'Point' coordinates missing. "
+                                     "Using Origin (0, 0) as mirroring reference."))
                 px, py = (0, 0)
 
         else:
@@ -406,7 +408,7 @@ class DblSidedTool(FlatCAMTool):
             try:
                 bb_obj = model_index_box.internalPointer().obj
             except Exception as e:
-                self.app.inform.emit("[WARNING_NOTCL] There is no Box object loaded ...")
+                self.app.inform.emit(_("[WARNING_NOTCL] There is no Box object loaded ..."))
                 return
 
             xmin, ymin, xmax, ymax = bb_obj.bounds()
@@ -416,7 +418,7 @@ class DblSidedTool(FlatCAMTool):
         fcobj.mirror(axis, [px, py])
         self.app.object_changed.emit(fcobj)
         fcobj.plot()
-        self.app.inform.emit("[success] Gerber %s was mirrored..." % str(fcobj.options['name']))
+        self.app.inform.emit(_("[success] Gerber %s was mirrored...") % str(fcobj.options['name']))
 
     def on_mirror_exc(self):
         selection_index = self.exc_object_combo.currentIndex()
@@ -425,11 +427,11 @@ class DblSidedTool(FlatCAMTool):
         try:
             fcobj = model_index.internalPointer().obj
         except Exception as e:
-            self.app.inform.emit("[WARNING_NOTCL] There is no Excellon object loaded ...")
+            self.app.inform.emit(_("[WARNING_NOTCL] There is no Excellon object loaded ..."))
             return
 
         if not isinstance(fcobj, FlatCAMExcellon):
-            self.app.inform.emit("[ERROR_NOTCL] Only Gerber, Excellon and Geometry objects can be mirrored.")
+            self.app.inform.emit(_("[ERROR_NOTCL] Only Gerber, Excellon and Geometry objects can be mirrored."))
             return
 
         axis = self.mirror_axis.get_value()
@@ -440,8 +442,8 @@ class DblSidedTool(FlatCAMTool):
                 px, py = self.point_entry.get_value()
             except Exception as e:
                 log.debug("DblSidedTool.on_mirror_geo() --> %s" % str(e))
-                self.app.inform.emit("[WARNING_NOTCL] There are no Point coordinates in the Point field. "
-                                     "Add coords and try again ...")
+                self.app.inform.emit(_("[WARNING_NOTCL] There are no Point coordinates in the Point field. "
+                                     "Add coords and try again ..."))
                 return
         else:
             selection_index_box = self.box_combo.currentIndex()
@@ -450,7 +452,7 @@ class DblSidedTool(FlatCAMTool):
                 bb_obj = model_index_box.internalPointer().obj
             except Exception as e:
                 log.debug("DblSidedTool.on_mirror_geo() --> %s" % str(e))
-                self.app.inform.emit("[WARNING_NOTCL] There is no Box object loaded ...")
+                self.app.inform.emit(_("[WARNING_NOTCL] There is no Box object loaded ..."))
                 return
 
             xmin, ymin, xmax, ymax = bb_obj.bounds()
@@ -460,7 +462,7 @@ class DblSidedTool(FlatCAMTool):
         fcobj.mirror(axis, [px, py])
         self.app.object_changed.emit(fcobj)
         fcobj.plot()
-        self.app.inform.emit("[success] Excellon %s was mirrored..." % str(fcobj.options['name']))
+        self.app.inform.emit(_("[success] Excellon %s was mirrored...") % str(fcobj.options['name']))
 
     def on_mirror_geo(self):
         selection_index = self.geo_object_combo.currentIndex()
@@ -469,11 +471,11 @@ class DblSidedTool(FlatCAMTool):
         try:
             fcobj = model_index.internalPointer().obj
         except Exception as e:
-            self.app.inform.emit("[WARNING_NOTCL] There is no Geometry object loaded ...")
+            self.app.inform.emit(_("[WARNING_NOTCL] There is no Geometry object loaded ..."))
             return
 
         if not isinstance(fcobj, FlatCAMGeometry):
-            self.app.inform.emit("[ERROR_NOTCL] Only Gerber, Excellon and Geometry objects can be mirrored.")
+            self.app.inform.emit(_("[ERROR_NOTCL] Only Gerber, Excellon and Geometry objects can be mirrored."))
             return
 
         axis = self.mirror_axis.get_value()
@@ -487,7 +489,7 @@ class DblSidedTool(FlatCAMTool):
             try:
                 bb_obj = model_index_box.internalPointer().obj
             except Exception as e:
-                self.app.inform.emit("[WARNING_NOTCL] There is no Box object loaded ...")
+                self.app.inform.emit(_("[WARNING_NOTCL] There is no Box object loaded ..."))
                 return
 
             xmin, ymin, xmax, ymax = bb_obj.bounds()
@@ -497,7 +499,7 @@ class DblSidedTool(FlatCAMTool):
         fcobj.mirror(axis, [px, py])
         self.app.object_changed.emit(fcobj)
         fcobj.plot()
-        self.app.inform.emit("[success] Geometry %s was mirrored..." % str(fcobj.options['name']))
+        self.app.inform.emit(_("[success] Geometry %s was mirrored...") % str(fcobj.options['name']))
 
     def on_point_add(self):
         val = self.app.defaults["global_point_clipboard_format"] % (self.app.pos[0], self.app.pos[1])

flatcamTools/ToolFilm.py

@@ -6,7 +6,7 @@ from PyQt5 import QtGui, QtCore, QtWidgets
 
 class Film(FlatCAMTool):
 
-    toolName = "Film PCB"
+    toolName = _("Film PCB")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
@@ -37,12 +37,12 @@ class Film(FlatCAMTool):
         self.tf_type_obj_combo.setItemIcon(0, QtGui.QIcon("share/flatcam_icon16.png"))
         self.tf_type_obj_combo.setItemIcon(2, QtGui.QIcon("share/geometry16.png"))
 
-        self.tf_type_obj_combo_label = QtWidgets.QLabel("Object Type:")
+        self.tf_type_obj_combo_label = QtWidgets.QLabel(_("Object Type:"))
         self.tf_type_obj_combo_label.setToolTip(
-            "Specify the type of object for which to create the film.\n"
+            _("Specify the type of object for which to create the film.\n"
             "The object can be of type: Gerber or Geometry.\n"
             "The selection here decide the type of objects that will be\n"
-            "in the Film Object combobox."
+            "in the Film Object combobox.")
         )
         tf_form_layout.addRow(self.tf_type_obj_combo_label, self.tf_type_obj_combo)
 
@@ -52,9 +52,9 @@ class Film(FlatCAMTool):
         self.tf_object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
         self.tf_object_combo.setCurrentIndex(1)
 
-        self.tf_object_label = QtWidgets.QLabel("Film Object:")
+        self.tf_object_label = QtWidgets.QLabel(_("Film Object:"))
         self.tf_object_label.setToolTip(
-            "Object for which to create the film."
+            _("Object for which to create the film.")
         )
         tf_form_layout.addRow(self.tf_object_label, self.tf_object_combo)
 
@@ -70,12 +70,12 @@ class Film(FlatCAMTool):
         self.tf_type_box_combo.setItemIcon(0, QtGui.QIcon("share/flatcam_icon16.png"))
         self.tf_type_box_combo.setItemIcon(2, QtGui.QIcon("share/geometry16.png"))
 
-        self.tf_type_box_combo_label = QtWidgets.QLabel("Box Type:")
+        self.tf_type_box_combo_label = QtWidgets.QLabel(_("Box Type:"))
         self.tf_type_box_combo_label.setToolTip(
-            "Specify the type of object to be used as an container for\n"
+            _("Specify the type of object to be used as an container for\n"
             "film creation. It can be: Gerber or Geometry type."
             "The selection here decide the type of objects that will be\n"
-            "in the Box Object combobox."
+            "in the Box Object combobox.")
         )
         tf_form_layout.addRow(self.tf_type_box_combo_label, self.tf_type_box_combo)
 
@@ -85,50 +85,51 @@ class Film(FlatCAMTool):
         self.tf_box_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
         self.tf_box_combo.setCurrentIndex(1)
 
-        self.tf_box_combo_label = QtWidgets.QLabel("Box Object:")
+        self.tf_box_combo_label = QtWidgets.QLabel(_("Box Object:"))
         self.tf_box_combo_label.setToolTip(
-            "The actual object that is used a container for the\n "
+            _("The actual object that is used a container for the\n "
             "selected object for which we create the film.\n"
             "Usually it is the PCB outline but it can be also the\n"
             "same object for which the film is created.")
+        )
         tf_form_layout.addRow(self.tf_box_combo_label, self.tf_box_combo)
 
         # Film Type
         self.film_type = RadioSet([{'label': 'Positive', 'value': 'pos'},
                                      {'label': 'Negative', 'value': 'neg'}])
-        self.film_type_label = QtWidgets.QLabel("Film Type:")
+        self.film_type_label = QtWidgets.QLabel(_("Film Type:"))
         self.film_type_label.setToolTip(
-            "Generate a Positive black film or a Negative film.\n"
+            _("Generate a Positive black film or a Negative film.\n"
             "Positive means that it will print the features\n"
             "with black on a white canvas.\n"
             "Negative means that it will print the features\n"
             "with white on a black canvas.\n"
-            "The Film format is SVG."
+            "The Film format is SVG.")
         )
         tf_form_layout.addRow(self.film_type_label, self.film_type)
 
         # Boundary for negative film generation
 
         self.boundary_entry = FCEntry()
-        self.boundary_label = QtWidgets.QLabel("Border:")
+        self.boundary_label = QtWidgets.QLabel(_("Border:"))
         self.boundary_label.setToolTip(
-            "Specify a border around the object.\n"
+            _("Specify a border around the object.\n"
             "Only for negative film.\n"
             "It helps if we use as a Box Object the same \n"
             "object as in Film Object. It will create a thick\n"
             "black bar around the actual print allowing for a\n"
             "better delimitation of the outline features which are of\n"
             "white color like the rest and which may confound with the\n"
-            "surroundings if not for this border."
+            "surroundings if not for this border.")
         )
         tf_form_layout.addRow(self.boundary_label, self.boundary_entry)
 
         self.film_scale_entry = FCEntry()
-        self.film_scale_label = QtWidgets.QLabel("Scale Stroke:")
+        self.film_scale_label = QtWidgets.QLabel(_("Scale Stroke:"))
         self.film_scale_label.setToolTip(
-            "Scale the line stroke thickness of each feature in the SVG file.\n"
+            _("Scale the line stroke thickness of each feature in the SVG file.\n"
             "It means that the line that envelope each SVG feature will be thicker or thinner,\n"
-            "therefore the fine features may be more affected by this parameter."
+            "therefore the fine features may be more affected by this parameter.")
         )
         tf_form_layout.addRow(self.film_scale_label, self.film_scale_entry)
 
@@ -137,12 +138,12 @@ class Film(FlatCAMTool):
         self.layout.addLayout(hlay)
         hlay.addStretch()
 
-        self.film_object_button = QtWidgets.QPushButton("Save Film")
+        self.film_object_button = QtWidgets.QPushButton(_("Save Film"))
         self.film_object_button.setToolTip(
-            "Create a Film for the selected object, within\n"
+            _("Create a Film for the selected object, within\n"
             "the specified box. Does not create a new \n "
             "FlatCAM object, but directly save it in SVG format\n"
-            "which can be opened with Inkscape."
+            "which can be opened with Inkscape.")
         )
         hlay.addWidget(self.film_object_button)
 
@@ -180,7 +181,7 @@ class Film(FlatCAMTool):
         FlatCAMTool.run(self)
         self.set_tool_ui()
 
-        self.app.ui.notebook.setTabText(2, "Film Tool")
+        self.app.ui.notebook.setTabText(2, _("Film Tool"))
 
     def install(self, icon=None, separator=None, **kwargs):
         FlatCAMTool.install(self, icon, separator, shortcut='ALT+L', **kwargs)
@@ -201,13 +202,13 @@ class Film(FlatCAMTool):
         try:
             name = self.tf_object_combo.currentText()
         except:
-            self.app.inform.emit("[ERROR_NOTCL] No FlatCAM object selected. Load an object for Film and retry.")
+            self.app.inform.emit(_("[ERROR_NOTCL] No FlatCAM object selected. Load an object for Film and retry."))
             return
 
         try:
             boxname = self.tf_box_combo.currentText()
         except:
-            self.app.inform.emit("[ERROR_NOTCL] No FlatCAM object selected. Load an object for Box and retry.")
+            self.app.inform.emit(_("[ERROR_NOTCL] No FlatCAM object selected. Load an object for Box and retry."))
             return
 
         try:
@@ -217,51 +218,51 @@ class Film(FlatCAMTool):
             try:
                 border = float(self.boundary_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         try:
             scale_stroke_width = int(self.film_scale_entry.get_value())
         except ValueError:
-            self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                 "use a number.")
+            self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                 "use a number."))
             return
 
         if border is None:
             border = 0
 
-        self.app.inform.emit("Generating Film ...")
+        self.app.inform.emit(_("Generating Film ..."))
 
         if self.film_type.get_value() == "pos":
             try:
                 filename, _ = QtWidgets.QFileDialog.getSaveFileName(
-                    caption="Export SVG positive",
+                    caption=_("Export SVG positive"),
                     directory=self.app.get_last_save_folder() + '/' + name,
                     filter="*.svg")
             except TypeError:
-                filename, _ = QtWidgets.QFileDialog.getSaveFileName(caption="Export SVG positive")
+                filename, _ = QtWidgets.QFileDialog.getSaveFileName(caption=_("Export SVG positive"))
 
             filename = str(filename)
 
             if str(filename) == "":
-                self.app.inform.emit("[WARNING_NOTCL]Export SVG positive cancelled.")
+                self.app.inform.emit(_("[WARNING_NOTCL]Export SVG positive cancelled."))
                 return
             else:
                 self.app.export_svg_black(name, boxname, filename, scale_factor=scale_stroke_width)
         else:
             try:
                 filename, _ = QtWidgets.QFileDialog.getSaveFileName(
-                    caption="Export SVG negative",
+                    caption=_("Export SVG negative"),
                     directory=self.app.get_last_save_folder() + '/' + name,
                     filter="*.svg")
             except TypeError:
-                filename, _ = QtWidgets.QFileDialog.getSaveFileName(caption="Export SVG negative")
+                filename, _ = QtWidgets.QFileDialog.getSaveFileName(caption=_("Export SVG negative"))
 
             filename = str(filename)
 
             if str(filename) == "":
-                self.app.inform.emit("[WARNING_NOTCL]Export SVG negative cancelled.")
+                self.app.inform.emit(_("[WARNING_NOTCL]Export SVG negative cancelled."))
                 return
             else:
                 self.app.export_svg_negative(name, boxname, filename, border, scale_factor=scale_stroke_width)

flatcamTools/ToolImage.py

@@ -6,13 +6,13 @@ from PyQt5 import QtGui, QtCore, QtWidgets
 
 class ToolImage(FlatCAMTool):
 
-    toolName = "Image as Object"
+    toolName = _("Image as Object")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
 
         # Title
-        title_label = QtWidgets.QLabel("%s" % 'Image to PCB')
+        title_label = QtWidgets.QLabel("%s" % _('Image to PCB'))
         title_label.setStyleSheet("""
                         QLabel
                         {
@@ -34,26 +34,26 @@ class ToolImage(FlatCAMTool):
         self.tf_type_obj_combo.setItemIcon(0, QtGui.QIcon("share/flatcam_icon16.png"))
         self.tf_type_obj_combo.setItemIcon(1, QtGui.QIcon("share/geometry16.png"))
 
-        self.tf_type_obj_combo_label = QtWidgets.QLabel("Object Type:")
+        self.tf_type_obj_combo_label = QtWidgets.QLabel(_("Object Type:"))
         self.tf_type_obj_combo_label.setToolTip(
-            "Specify the type of object to create from the image.\n"
-            "It can be of type: Gerber or Geometry."
+           _( "Specify the type of object to create from the image.\n"
+            "It can be of type: Gerber or Geometry.")
 
         )
         ti_form_layout.addRow(self.tf_type_obj_combo_label, self.tf_type_obj_combo)
 
         # DPI value of the imported image
         self.dpi_entry = IntEntry()
-        self.dpi_label = QtWidgets.QLabel("DPI value:")
+        self.dpi_label = QtWidgets.QLabel(_("DPI value:"))
         self.dpi_label.setToolTip(
-            "Specify a DPI value for the image."
+           _( "Specify a DPI value for the image.")
         )
         ti_form_layout.addRow(self.dpi_label, self.dpi_entry)
 
         self.emty_lbl = QtWidgets.QLabel("")
         self.layout.addWidget(self.emty_lbl)
 
-        self.detail_label = QtWidgets.QLabel("<font size=4><b>Level of detail:</b>")
+        self.detail_label = QtWidgets.QLabel("<font size=4><b>%s:</b>" % _('Level of detail'))
         self.layout.addWidget(self.detail_label)
 
         ti2_form_layout = QtWidgets.QFormLayout()
@@ -62,56 +62,56 @@ class ToolImage(FlatCAMTool):
         # Type of image interpretation
         self.image_type = RadioSet([{'label': 'B/W', 'value': 'black'},
                                      {'label': 'Color', 'value': 'color'}])
-        self.image_type_label = QtWidgets.QLabel("<b>Image type:</b>")
+        self.image_type_label = QtWidgets.QLabel("<b>%s:</b>" % _('Image type'))
         self.image_type_label.setToolTip(
-            "Choose a method for the image interpretation.\n"
-            "B/W means a black & white image. Color means a colored image."
+            _("Choose a method for the image interpretation.\n"
+            "B/W means a black & white image. Color means a colored image.")
         )
         ti2_form_layout.addRow(self.image_type_label, self.image_type)
 
         # Mask value of the imported image when image monochrome
         self.mask_bw_entry = IntEntry()
-        self.mask_bw_label = QtWidgets.QLabel("Mask value <b>B/W</b>:")
+        self.mask_bw_label = QtWidgets.QLabel("%s <b>B/W</b>:" % _('Mask value'))
         self.mask_bw_label.setToolTip(
-            "Mask for monochrome image.\n"
+            _("Mask for monochrome image.\n"
             "Takes values between [0 ... 255].\n"
             "Decides the level of details to include\n"
             "in the resulting geometry.\n"
             "0 means no detail and 255 means everything \n"
-            "(which is totally black)."
+            "(which is totally black).")
         )
         ti2_form_layout.addRow(self.mask_bw_label, self.mask_bw_entry)
 
         # Mask value of the imported image for RED color when image color
         self.mask_r_entry = IntEntry()
-        self.mask_r_label = QtWidgets.QLabel("Mask value <b>R:</b>")
+        self.mask_r_label = QtWidgets.QLabel("%s <b>R:</b>" % _('Mask value'))
         self.mask_r_label.setToolTip(
-            "Mask for RED color.\n"
+            _("Mask for RED color.\n"
             "Takes values between [0 ... 255].\n"
             "Decides the level of details to include\n"
-            "in the resulting geometry."
+            "in the resulting geometry.")
         )
         ti2_form_layout.addRow(self.mask_r_label, self.mask_r_entry)
 
         # Mask value of the imported image for GREEN color when image color
         self.mask_g_entry = IntEntry()
-        self.mask_g_label = QtWidgets.QLabel("Mask value <b>G:</b>")
+        self.mask_g_label = QtWidgets.QLabel("%s <b>G:</b>" % _('Mask value'))
         self.mask_g_label.setToolTip(
-            "Mask for GREEN color.\n"
+            _("Mask for GREEN color.\n"
             "Takes values between [0 ... 255].\n"
             "Decides the level of details to include\n"
-            "in the resulting geometry."
+            "in the resulting geometry.")
         )
         ti2_form_layout.addRow(self.mask_g_label, self.mask_g_entry)
 
         # Mask value of the imported image for BLUE color when image color
         self.mask_b_entry = IntEntry()
-        self.mask_b_label = QtWidgets.QLabel("Mask value <b>B:</b>")
+        self.mask_b_label = QtWidgets.QLabel("%s <b>B:</b>" % _('Mask value'))
         self.mask_b_label.setToolTip(
-            "Mask for BLUE color.\n"
+            _("Mask for BLUE color.\n"
             "Takes values between [0 ... 255].\n"
             "Decides the level of details to include\n"
-            "in the resulting geometry."
+            "in the resulting geometry.")
         )
         ti2_form_layout.addRow(self.mask_b_label, self.mask_b_entry)
 
@@ -120,9 +120,9 @@ class ToolImage(FlatCAMTool):
         self.layout.addLayout(hlay)
         hlay.addStretch()
 
-        self.import_button = QtWidgets.QPushButton("Import image")
+        self.import_button = QtWidgets.QPushButton(_("Import image"))
         self.import_button.setToolTip(
-            "Open a image of raster type and then import it in FlatCAM."
+            _("Open a image of raster type and then import it in FlatCAM.")
         )
         hlay.addWidget(self.import_button)
 
@@ -148,7 +148,7 @@ class ToolImage(FlatCAMTool):
         FlatCAMTool.run(self)
         self.set_tool_ui()
 
-        self.app.ui.notebook.setTabText(2, "Image Tool")
+        self.app.ui.notebook.setTabText(2, _("Image Tool"))
 
     def install(self, icon=None, separator=None, **kwargs):
         FlatCAMTool.install(self, icon, separator, **kwargs)
@@ -178,10 +178,10 @@ class ToolImage(FlatCAMTool):
                  "Jpeg File (*.JPG);;" \
                  "All Files (*.*)"
         try:
-            filename, _ = QtWidgets.QFileDialog.getOpenFileName(caption="Import IMAGE",
+            filename, _ = QtWidgets.QFileDialog.getOpenFileName(caption=_("Import IMAGE"),
                                                          directory=self.app.get_last_folder(), filter=filter)
         except TypeError:
-            filename, _ = QtWidgets.QFileDialog.getOpenFileName(caption="Import IMAGE", filter=filter)
+            filename, _ = QtWidgets.QFileDialog.getOpenFileName(caption=_("Import IMAGE"), filter=filter)
 
         filename = str(filename)
         type = self.tf_type_obj_combo.get_value().lower()
@@ -191,7 +191,7 @@ class ToolImage(FlatCAMTool):
                 self.mask_b_entry.get_value()]
 
         if filename == "":
-            self.app.inform.emit("Open cancelled.")
+            self.app.inform.emit(_("Open cancelled."))
         else:
             self.app.worker_task.emit({'fcn': self.app.import_image,
                                        'params': [filename, type, dpi, mode, mask]})

flatcamTools/ToolMeasurement.py

@@ -7,7 +7,7 @@ from math import sqrt
 
 class Measurement(FlatCAMTool):
 
-    toolName = "Measurement"
+    toolName = _("Measurement")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
@@ -28,51 +28,51 @@ class Measurement(FlatCAMTool):
         form_layout_child_2 = QtWidgets.QFormLayout()
         form_layout_child_3 = QtWidgets.QFormLayout()
 
-        self.start_label = QtWidgets.QLabel("<b>Start</b> Coords:")
-        self.start_label.setToolTip("This is measuring Start point coordinates.")
+        self.start_label = QtWidgets.QLabel("<b>%s</b> %s:" % (_('Start'), _('Coords')))
+        self.start_label.setToolTip(_("This is measuring Start point coordinates."))
 
-        self.stop_label = QtWidgets.QLabel("<b>Stop</b> Coords:")
-        self.stop_label.setToolTip("This is the measuring Stop point coordinates.")
+        self.stop_label = QtWidgets.QLabel("<b>%s</b> %s:" % (_('Stop'), _('Coords')))
+        self.stop_label.setToolTip(_("This is the measuring Stop point coordinates."))
 
         self.distance_x_label = QtWidgets.QLabel("Dx:")
-        self.distance_x_label.setToolTip("This is the distance measured over the X axis.")
+        self.distance_x_label.setToolTip(_("This is the distance measured over the X axis."))
 
         self.distance_y_label = QtWidgets.QLabel("Dy:")
-        self.distance_y_label.setToolTip("This is the distance measured over the Y axis.")
+        self.distance_y_label.setToolTip(_("This is the distance measured over the Y axis."))
 
-        self.total_distance_label = QtWidgets.QLabel("<b>DISTANCE:</b>")
-        self.total_distance_label.setToolTip("This is the point to point Euclidian distance.")
+        self.total_distance_label = QtWidgets.QLabel("<b>%s:</b>" % _('DISTANCE'))
+        self.total_distance_label.setToolTip(_("This is the point to point Euclidian distance."))
 
         self.units_entry_1 = FCEntry()
-        self.units_entry_1.setToolTip("Those are the units in which the distance is measured.")
+        self.units_entry_1.setToolTip(_("Those are the units in which the distance is measured."))
         self.units_entry_1.setDisabled(True)
         self.units_entry_1.setFocusPolicy(QtCore.Qt.NoFocus)
         self.units_entry_1.setFrame(False)
         self.units_entry_1.setFixedWidth(30)
 
         self.units_entry_2 = FCEntry()
-        self.units_entry_2.setToolTip("Those are the units in which the distance is measured.")
+        self.units_entry_2.setToolTip(_("Those are the units in which the distance is measured."))
         self.units_entry_2.setDisabled(True)
         self.units_entry_2.setFocusPolicy(QtCore.Qt.NoFocus)
         self.units_entry_2.setFrame(False)
         self.units_entry_2.setFixedWidth(30)
 
         self.units_entry_3 = FCEntry()
-        self.units_entry_3.setToolTip("Those are the units in which the distance is measured.")
+        self.units_entry_3.setToolTip(_("Those are the units in which the distance is measured."))
         self.units_entry_3.setDisabled(True)
         self.units_entry_3.setFocusPolicy(QtCore.Qt.NoFocus)
         self.units_entry_3.setFrame(False)
         self.units_entry_3.setFixedWidth(30)
 
         self.units_entry_4 = FCEntry()
-        self.units_entry_4.setToolTip("Those are the units in which the distance is measured.")
+        self.units_entry_4.setToolTip(_("Those are the units in which the distance is measured."))
         self.units_entry_4.setDisabled(True)
         self.units_entry_4.setFocusPolicy(QtCore.Qt.NoFocus)
         self.units_entry_4.setFrame(False)
         self.units_entry_4.setFixedWidth(30)
 
         self.units_entry_5 = FCEntry()
-        self.units_entry_5.setToolTip("Those are the units in which the distance is measured.")
+        self.units_entry_5.setToolTip(_("Those are the units in which the distance is measured."))
         self.units_entry_5.setDisabled(True)
         self.units_entry_5.setFocusPolicy(QtCore.Qt.NoFocus)
         self.units_entry_5.setFrame(False)
@@ -80,32 +80,32 @@ class Measurement(FlatCAMTool):
 
         self.start_entry = FCEntry()
         self.start_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.start_entry.setToolTip("This is measuring Start point coordinates.")
+        self.start_entry.setToolTip(_("This is measuring Start point coordinates."))
         self.start_entry.setFixedWidth(100)
 
         self.stop_entry = FCEntry()
         self.stop_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.stop_entry.setToolTip("This is the measuring Stop point coordinates.")
+        self.stop_entry.setToolTip(_("This is the measuring Stop point coordinates."))
         self.stop_entry.setFixedWidth(100)
 
         self.distance_x_entry = FCEntry()
         self.distance_x_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.distance_x_entry.setToolTip("This is the distance measured over the X axis.")
+        self.distance_x_entry.setToolTip(_("This is the distance measured over the X axis."))
         self.distance_x_entry.setFixedWidth(100)
 
 
         self.distance_y_entry = FCEntry()
         self.distance_y_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.distance_y_entry.setToolTip("This is the distance measured over the Y axis.")
+        self.distance_y_entry.setToolTip(_("This is the distance measured over the Y axis."))
         self.distance_y_entry.setFixedWidth(100)
 
 
         self.total_distance_entry = FCEntry()
         self.total_distance_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
-        self.total_distance_entry.setToolTip("This is the point to point Euclidian distance.")
+        self.total_distance_entry.setToolTip(_("This is the point to point Euclidian distance."))
         self.total_distance_entry.setFixedWidth(100)
 
-        self.measure_btn = QtWidgets.QPushButton("Measure")
+        self.measure_btn = QtWidgets.QPushButton(_("Measure"))
         self.measure_btn.setFixedWidth(70)
         self.layout.addWidget(self.measure_btn)
 
@@ -159,7 +159,7 @@ class Measurement(FlatCAMTool):
         self.toggle()
 
         self.set_tool_ui()
-        self.app.ui.notebook.setTabText(2, "Meas. Tool")
+        self.app.ui.notebook.setTabText(2, _("Meas. Tool"))
 
     def install(self, icon=None, separator=None, **kwargs):
         FlatCAMTool.install(self, icon, separator, shortcut='CTRL+M', **kwargs)
@@ -250,7 +250,7 @@ class Measurement(FlatCAMTool):
             self.units_entry_4.set_value(str(self.units))
             self.units_entry_5.set_value(str(self.units))
 
-            self.app.inform.emit("MEASURING: Click on the Start point ...")
+            self.app.inform.emit(_("MEASURING: Click on the Start point ..."))
 
     def on_key_release_meas(self, event):
         if event.key == 'escape':
@@ -279,7 +279,7 @@ class Measurement(FlatCAMTool):
                     pos = pos_canvas[0], pos_canvas[1]
                 self.point1 = pos
                 self.start_entry.set_value("(%.4f, %.4f)" % pos)
-                self.app.inform.emit("MEASURING: Click on the Destination point ...")
+                self.app.inform.emit(_("MEASURING: Click on the Destination point ..."))
 
             if self.clicked_meas == 1:
                 try:
@@ -300,7 +300,7 @@ class Measurement(FlatCAMTool):
 
                     self.stop_entry.set_value("(%.4f, %.4f)" % pos)
 
-                    self.app.inform.emit("MEASURING: Result D(x) = %.4f | D(y) = %.4f | Distance = %.4f" %
+                    self.app.inform.emit(_("MEASURING: Result D(x) = %.4f | D(y) = %.4f | Distance = %.4f") %
                                          (abs(dx), abs(dy), abs(d)))
 
                     self.distance_x_entry.set_value('%.4f' % abs(dx))

flatcamTools/ToolMove.py

@@ -8,7 +8,7 @@ from copy import copy
 
 class ToolMove(FlatCAMTool):
 
-    toolName = "Move"
+    toolName = _("Move")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
@@ -63,14 +63,14 @@ class ToolMove(FlatCAMTool):
             self.app.command_active = "Move"
 
             if self.app.collection.get_selected():
-                self.app.inform.emit("MOVE: Click on the Start point ...")
+                self.app.inform.emit(_("MOVE: Click on the Start point ..."))
                 # draw the selection box
                 self.draw_sel_bbox()
             else:
                 self.setVisible(False)
                 # signal that there is no command active
                 self.app.command_active = None
-                self.app.inform.emit("[WARNING_NOTCL]MOVE action cancelled. No object(s) to move.")
+                self.app.inform.emit(_("[WARNING_NOTCL] MOVE action cancelled. No object(s) to move."))
 
     def on_left_click(self, event):
         # mouse click will be accepted only if the left button is clicked
@@ -92,7 +92,7 @@ class ToolMove(FlatCAMTool):
                 else:
                     self.point2 = copy(self.point1)
                     self.point1 = pos
-                self.app.inform.emit("MOVE: Click on the Destination point ...")
+                self.app.inform.emit(_("MOVE: Click on the Destination point ..."))
 
             if self.clicked_move == 1:
                 try:
@@ -110,14 +110,14 @@ class ToolMove(FlatCAMTool):
                     dx = pos[0] - self.point1[0]
                     dy = pos[1] - self.point1[1]
 
-                    proc = self.app.proc_container.new("Moving ...")
+                    proc = self.app.proc_container.new(_("Moving ..."))
 
                     def job_move(app_obj):
                         obj_list = self.app.collection.get_selected()
 
                         try:
                             if not obj_list:
-                                self.app.inform.emit("[WARNING_NOTCL] No object(s) selected.")
+                                self.app.inform.emit(_("[WARNING_NOTCL] No object(s) selected."))
                                 return "fail"
                             else:
                                 for sel_obj in obj_list:
@@ -140,13 +140,13 @@ class ToolMove(FlatCAMTool):
                                     # self.app.collection.set_active(sel_obj.options['name'])
                         except Exception as e:
                             proc.done()
-                            self.app.inform.emit('[ERROR_NOTCL] '
-                                                 'ToolMove.on_left_click() --> %s' % str(e))
+                            self.app.inform.emit(_('[ERROR_NOTCL] '
+                                                 'ToolMove.on_left_click() --> %s') % str(e))
                             return "fail"
                         proc.done()
                         # delete the selection bounding box
                         self.delete_shape()
-                        self.app.inform.emit('[success]%s object was moved ...' %
+                        self.app.inform.emit(_('[success]%s object was moved ...') %
                                              str(sel_obj.kind).capitalize())
 
                     self.app.worker_task.emit({'fcn': job_move, 'params': [self]})
@@ -156,8 +156,8 @@ class ToolMove(FlatCAMTool):
                     return
 
                 except TypeError:
-                    self.app.inform.emit('[ERROR_NOTCL] '
-                                         'ToolMove.on_left_click() --> Error when mouse left click.')
+                    self.app.inform.emit(_('[ERROR_NOTCL] '
+                                         'ToolMove.on_left_click() --> Error when mouse left click.'))
                     return
 
             self.clicked_move = 1
@@ -184,7 +184,7 @@ class ToolMove(FlatCAMTool):
     def on_key_press(self, event):
         if event.key == 'escape':
             # abort the move action
-            self.app.inform.emit("[WARNING_NOTCL]Move action cancelled.")
+            self.app.inform.emit(_("[WARNING_NOTCL]Move action cancelled."))
             self.toggle()
         return
 
@@ -196,7 +196,7 @@ class ToolMove(FlatCAMTool):
 
         obj_list = self.app.collection.get_selected()
         if not obj_list:
-            self.app.inform.emit("[WARNING_NOTCL]Object(s) not selected")
+            self.app.inform.emit(_("[WARNING_NOTCL]Object(s) not selected"))
             self.toggle()
         else:
             # if we have an object selected then we can safely activate the mouse events

flatcamTools/ToolNonCopperClear.py

@@ -6,7 +6,7 @@ import time
 
 class NonCopperClear(FlatCAMTool, Gerber):
 
-    toolName = "Non-Copper Clearing"
+    toolName = _("Non-Copper Clearing")
 
     def __init__(self, app):
         self.app = app
@@ -44,7 +44,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
 
         self.object_label = QtWidgets.QLabel("Gerber:")
         self.object_label.setToolTip(
-            "Gerber object to be cleared of excess copper.                        "
+            _("Gerber object to be cleared of excess copper.                        ")
         )
         e_lab_0 = QtWidgets.QLabel('')
 
@@ -52,10 +52,10 @@ class NonCopperClear(FlatCAMTool, Gerber):
         form_layout.addRow(e_lab_0)
 
         #### Tools ####
-        self.tools_table_label = QtWidgets.QLabel('<b>Tools Table</b>')
+        self.tools_table_label = QtWidgets.QLabel('<b>%s</b>' % _('Tools Table'))
         self.tools_table_label.setToolTip(
-            "Tools pool from which the algorithm\n"
-            "will pick the ones used for copper clearing."
+            _("Tools pool from which the algorithm\n"
+            "will pick the ones used for copper clearing.")
         )
         self.tools_box.addWidget(self.tools_table_label)
 
@@ -63,25 +63,25 @@ class NonCopperClear(FlatCAMTool, Gerber):
         self.tools_box.addWidget(self.tools_table)
 
         self.tools_table.setColumnCount(4)
-        self.tools_table.setHorizontalHeaderLabels(['#', 'Diameter', 'TT', ''])
+        self.tools_table.setHorizontalHeaderLabels(['#', _('Diameter'), 'TT', ''])
         self.tools_table.setColumnHidden(3, True)
         self.tools_table.setSortingEnabled(False)
         # self.tools_table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
 
         self.tools_table.horizontalHeaderItem(0).setToolTip(
-            "This is the Tool Number.\n"
+            _("This is the Tool Number.\n"
             "Non copper clearing will start with the tool with the biggest \n"
             "diameter, continuing until there are no more tools.\n"
             "Only tools that create NCC clearing geometry will still be present\n"
             "in the resulting geometry. This is because with some tools\n"
-            "this function will not be able to create painting geometry."
+            "this function will not be able to create painting geometry.")
             )
         self.tools_table.horizontalHeaderItem(1).setToolTip(
-            "Tool Diameter. It's value (in current FlatCAM units) \n"
-            "is the cut width into the material.")
+            _("Tool Diameter. It's value (in current FlatCAM units) \n"
+            "is the cut width into the material."))
 
         self.tools_table.horizontalHeaderItem(2).setToolTip(
-            "The Tool Type (TT) can be:<BR>"
+            _("The Tool Type (TT) can be:<BR>"
             "- <B>Circular</B> with 1 ... 4 teeth -> it is informative only. Being circular, <BR>"
             "the cut width in material is exactly the tool diameter.<BR>"
             "- <B>Ball</B> -> informative only and make reference to the Ball type endmill.<BR>"
@@ -91,7 +91,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
             "as the cut width into material will be equal with the value in the Tool Diameter "
             "column of this table.<BR>"
             "Choosing the <B>V-Shape</B> Tool Type automatically will select the Operation Type "
-            "in the resulting geometry as Isolation.")
+            "in the resulting geometry as Isolation."))
 
         self.empty_label = QtWidgets.QLabel('')
         self.tools_box.addWidget(self.empty_label)
@@ -100,9 +100,9 @@ class NonCopperClear(FlatCAMTool, Gerber):
         hlay = QtWidgets.QHBoxLayout()
         self.tools_box.addLayout(hlay)
 
-        self.addtool_entry_lbl = QtWidgets.QLabel('<b>Tool Dia:</b>')
+        self.addtool_entry_lbl = QtWidgets.QLabel('<b>%s:</b>' % _('Tool Dia'))
         self.addtool_entry_lbl.setToolTip(
-            "Diameter for the new tool to add in the Tool Table"
+            _("Diameter for the new tool to add in the Tool Table")
         )
         self.addtool_entry = FCEntry()
 
@@ -114,10 +114,10 @@ class NonCopperClear(FlatCAMTool, Gerber):
         grid2 = QtWidgets.QGridLayout()
         self.tools_box.addLayout(grid2)
 
-        self.addtool_btn = QtWidgets.QPushButton('Add')
+        self.addtool_btn = QtWidgets.QPushButton(_('Add'))
         self.addtool_btn.setToolTip(
-            "Add a new tool to the Tool Table\n"
-            "with the diameter specified above."
+            _("Add a new tool to the Tool Table\n"
+            "with the diameter specified above.")
         )
 
         # self.copytool_btn = QtWidgets.QPushButton('Copy')
@@ -126,10 +126,10 @@ class NonCopperClear(FlatCAMTool, Gerber):
         #     "by first selecting a row in the Tool Table."
         # )
 
-        self.deltool_btn = QtWidgets.QPushButton('Delete')
+        self.deltool_btn = QtWidgets.QPushButton(_('Delete'))
         self.deltool_btn.setToolTip(
-            "Delete a selection of tools in the Tool Table\n"
-            "by first selecting a row(s) in the Tool Table."
+            _("Delete a selection of tools in the Tool Table\n"
+            "by first selecting a row(s) in the Tool Table.")
         )
 
         grid2.addWidget(self.addtool_btn, 0, 0)
@@ -145,9 +145,9 @@ class NonCopperClear(FlatCAMTool, Gerber):
         e_lab_1 = QtWidgets.QLabel('')
         grid3.addWidget(e_lab_1, 0, 0)
 
-        nccoverlabel = QtWidgets.QLabel('Overlap:')
+        nccoverlabel = QtWidgets.QLabel(_('Overlap:'))
         nccoverlabel.setToolTip(
-            "How much (fraction) of the tool width to overlap each tool pass.\n"
+            _("How much (fraction) of the tool width to overlap each tool pass.\n"
             "Example:\n"
             "A value here of 0.25 means 25% from the tool diameter found above.\n\n"
             "Adjust the value starting with lower values\n"
@@ -155,27 +155,27 @@ class NonCopperClear(FlatCAMTool, Gerber):
             "not cleared.\n"
             "Lower values = faster processing, faster execution on PCB.\n"
             "Higher values = slow processing and slow execution on CNC\n"
-            "due of too many paths."
+            "due of too many paths.")
         )
         grid3.addWidget(nccoverlabel, 1, 0)
         self.ncc_overlap_entry = FCEntry()
         grid3.addWidget(self.ncc_overlap_entry, 1, 1)
 
-        nccmarginlabel = QtWidgets.QLabel('Margin:')
+        nccmarginlabel = QtWidgets.QLabel(_('Margin:'))
         nccmarginlabel.setToolTip(
-            "Bounding box margin."
+            _("Bounding box margin.")
         )
         grid3.addWidget(nccmarginlabel, 2, 0)
         self.ncc_margin_entry = FCEntry()
         grid3.addWidget(self.ncc_margin_entry, 2, 1)
 
         # Method
-        methodlabel = QtWidgets.QLabel('Method:')
+        methodlabel = QtWidgets.QLabel(_('Method:'))
         methodlabel.setToolTip(
-            "Algorithm for non-copper clearing:<BR>"
+            _("Algorithm for non-copper clearing:<BR>"
             "<B>Standard</B>: Fixed step inwards.<BR>"
             "<B>Seed-based</B>: Outwards from seed.<BR>"
-            "<B>Line-based</B>: Parallel lines."
+            "<B>Line-based</B>: Parallel lines.")
         )
         grid3.addWidget(methodlabel, 3, 0)
         self.ncc_method_radio = RadioSet([
@@ -186,42 +186,42 @@ class NonCopperClear(FlatCAMTool, Gerber):
         grid3.addWidget(self.ncc_method_radio, 3, 1)
 
         # Connect lines
-        pathconnectlabel = QtWidgets.QLabel("Connect:")
+        pathconnectlabel = QtWidgets.QLabel(_("Connect:"))
         pathconnectlabel.setToolTip(
-            "Draw lines between resulting\n"
-            "segments to minimize tool lifts."
+            _("Draw lines between resulting\n"
+            "segments to minimize tool lifts.")
         )
         grid3.addWidget(pathconnectlabel, 4, 0)
         self.ncc_connect_cb = FCCheckBox()
         grid3.addWidget(self.ncc_connect_cb, 4, 1)
 
-        contourlabel = QtWidgets.QLabel("Contour:")
+        contourlabel = QtWidgets.QLabel(_("Contour:"))
         contourlabel.setToolTip(
-            "Cut around the perimeter of the polygon\n"
-            "to trim rough edges."
+            _("Cut around the perimeter of the polygon\n"
+            "to trim rough edges.")
         )
         grid3.addWidget(contourlabel, 5, 0)
         self.ncc_contour_cb = FCCheckBox()
         grid3.addWidget(self.ncc_contour_cb, 5, 1)
 
-        restlabel = QtWidgets.QLabel("Rest M.:")
+        restlabel = QtWidgets.QLabel(_("Rest M.:"))
         restlabel.setToolTip(
-            "If checked, use 'rest machining'.\n"
+            _("If checked, use 'rest machining'.\n"
             "Basically it will clear copper outside PCB features,\n"
             "using the biggest tool and continue with the next tools,\n"
             "from bigger to smaller, to clear areas of copper that\n"
             "could not be cleared by previous tool, until there is\n"
             "no more copper to clear or there are no more tools.\n"
-            "If not checked, use the standard algorithm."
+            "If not checked, use the standard algorithm.")
         )
         grid3.addWidget(restlabel, 6, 0)
         self.ncc_rest_cb = FCCheckBox()
         grid3.addWidget(self.ncc_rest_cb, 6, 1)
 
-        self.generate_ncc_button = QtWidgets.QPushButton('Generate Geometry')
+        self.generate_ncc_button = QtWidgets.QPushButton(_('Generate Geometry'))
         self.generate_ncc_button.setToolTip(
-            "Create the Geometry Object\n"
-            "for non-copper routing."
+            _("Create the Geometry Object\n"
+            "for non-copper routing.")
         )
         self.tools_box.addWidget(self.generate_ncc_button)
 
@@ -260,7 +260,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
         self.set_tool_ui()
 
         self.build_ui()
-        self.app.ui.notebook.setTabText(2, "NCC Tool")
+        self.app.ui.notebook.setTabText(2, _("NCC Tool"))
 
     def set_tool_ui(self):
         self.tools_frame.show()
@@ -455,16 +455,16 @@ class NonCopperClear(FlatCAMTool, Gerber):
                 try:
                     tool_dia = float(self.addtool_entry.get_value().replace(',', '.'))
                 except ValueError:
-                    self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                         "use a number.")
+                    self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                         "use a number."))
                     return
             if tool_dia is None:
                 self.build_ui()
-                self.app.inform.emit("[WARNING_NOTCL] Please enter a tool diameter to add, in Float format.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Please enter a tool diameter to add, in Float format."))
                 return
 
         if tool_dia == 0:
-            self.app.inform.emit("[WARNING_NOTCL] Please enter a tool diameter with non-zero value, in Float format.")
+            self.app.inform.emit(_("[WARNING_NOTCL] Please enter a tool diameter with non-zero value, in Float format."))
             return
 
         # construct a list of all 'tooluid' in the self.tools
@@ -488,12 +488,12 @@ class NonCopperClear(FlatCAMTool, Gerber):
 
         if float('%.4f' % tool_dia) in tool_dias:
             if muted is None:
-                self.app.inform.emit("[WARNING_NOTCL]Adding tool cancelled. Tool already in Tool Table.")
+                self.app.inform.emit(_("[WARNING_NOTCL]Adding tool cancelled. Tool already in Tool Table."))
             self.tools_table.itemChanged.connect(self.on_tool_edit)
             return
         else:
             if muted is None:
-                self.app.inform.emit("[success] New tool added to Tool Table.")
+                self.app.inform.emit(_("[success] New tool added to Tool Table."))
             self.ncc_tools.update({
                 int(self.tooluid): {
                     'tooldia': float('%.4f' % tool_dia),
@@ -526,8 +526,8 @@ class NonCopperClear(FlatCAMTool, Gerber):
                 try:
                     new_tool_dia = float(self.tools_table.item(row, 1).text().replace(',', '.'))
                 except ValueError:
-                    self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                         "use a number.")
+                    self.app.inform.emit(_("[ERROR_NOTCL] Wrong value format entered, "
+                                         "use a number."))
                     return
 
             tooluid = int(self.tools_table.item(row, 3).text())
@@ -535,7 +535,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
             # identify the tool that was edited and get it's tooluid
             if new_tool_dia not in tool_dias:
                 self.ncc_tools[tooluid]['tooldia'] = new_tool_dia
-                self.app.inform.emit("[success] Tool from Tool Table was edited.")
+                self.app.inform.emit(_("[success] Tool from Tool Table was edited."))
                 self.build_ui()
                 return
             else:
@@ -546,7 +546,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
                         break
                 restore_dia_item = self.tools_table.item(row, 1)
                 restore_dia_item.setText(str(old_tool_dia))
-                self.app.inform.emit("[WARNING_NOTCL] Edit cancelled. New diameter value is already in the Tool Table.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Edit cancelled. New diameter value is already in the Tool Table."))
         self.build_ui()
 
     def on_tool_delete(self, rows_to_delete=None, all=None):
@@ -585,12 +585,12 @@ class NonCopperClear(FlatCAMTool, Gerber):
                     self.ncc_tools.pop(t, None)
 
         except AttributeError:
-            self.app.inform.emit("[WARNING_NOTCL]Delete failed. Select a tool to delete.")
+            self.app.inform.emit(_("[WARNING_NOTCL]Delete failed. Select a tool to delete."))
             return
         except Exception as e:
             log.debug(str(e))
 
-        self.app.inform.emit("[success] Tool(s) deleted from Tool Table.")
+        self.app.inform.emit(_("[success] Tool(s) deleted from Tool Table."))
         self.build_ui()
 
     def on_ncc(self):
@@ -602,8 +602,8 @@ class NonCopperClear(FlatCAMTool, Gerber):
             try:
                 over = float(self.ncc_overlap_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         over = over if over else self.app.defaults["tools_nccoverlap"]
 
@@ -614,8 +614,8 @@ class NonCopperClear(FlatCAMTool, Gerber):
             try:
                 margin = float(self.ncc_margin_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         margin = margin if margin else self.app.defaults["tools_nccmargin"]
 
@@ -636,14 +636,14 @@ class NonCopperClear(FlatCAMTool, Gerber):
         try:
             self.ncc_obj = self.app.collection.get_by_name(self.obj_name)
         except:
-            self.app.inform.emit("[ERROR_NOTCL]Could not retrieve object: %s" % self.obj_name)
+            self.app.inform.emit(_("[ERROR_NOTCL]Could not retrieve object: %s") % self.obj_name)
             return "Could not retrieve object: %s" % self.obj_name
 
         # Prepare non-copper polygons
         try:
             bounding_box = self.ncc_obj.solid_geometry.envelope.buffer(distance=margin, join_style=JOIN_STYLE.mitre)
         except AttributeError:
-            self.app.inform.emit("[ERROR_NOTCL]No Gerber file available.")
+            self.app.inform.emit(_("[ERROR_NOTCL]No Gerber file available."))
             return
 
         # calculate the empty area by subtracting the solid_geometry from the object bounding box geometry
@@ -681,7 +681,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
         sorted_tools.sort(reverse=True)
 
         # Do job in background
-        proc = self.app.proc_container.new("Clearing Non-Copper areas.")
+        proc = self.app.proc_container.new(_("Clearing Non-Copper areas."))
 
         def initialize(geo_obj, app_obj):
             assert isinstance(geo_obj, FlatCAMGeometry), \
@@ -699,7 +699,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
             current_uid = int(1)
 
             for tool in sorted_tools:
-                self.app.inform.emit('[success] Non-Copper Clearing with ToolDia = %s started.' % str(tool))
+                self.app.inform.emit(_('[success] Non-Copper Clearing with ToolDia = %s started.') % str(tool))
                 cleared_geo[:] = []
 
                 # Get remaining tools offset
@@ -768,22 +768,22 @@ class NonCopperClear(FlatCAMTool, Gerber):
                 app_obj.new_object("geometry", name, initialize)
             except Exception as e:
                 proc.done()
-                self.app.inform.emit('[ERROR_NOTCL] NCCTool.clear_non_copper() --> %s' % str(e))
+                self.app.inform.emit(_('[ERROR_NOTCL] NCCTool.clear_non_copper() --> %s') % str(e))
                 return
             proc.done()
 
             if app_obj.poly_not_cleared is False:
-                self.app.inform.emit('[success] NCC Tool finished.')
+                self.app.inform.emit(_('[success] NCC Tool finished.'))
             else:
-                self.app.inform.emit('[WARNING_NOTCL] NCC Tool finished but some PCB features could not be cleared. '
-                                     'Check the result.')
+                self.app.inform.emit(_('[WARNING_NOTCL] NCC Tool finished but some PCB features could not be cleared. '
+                                     'Check the result.'))
             # reset the variable for next use
             app_obj.poly_not_cleared = False
 
             # focus on Selected Tab
             self.app.ui.notebook.setCurrentWidget(self.app.ui.selected_tab)
             self.tools_frame.hide()
-            self.app.ui.notebook.setTabText(2, "Tools")
+            self.app.ui.notebook.setTabText(2, _("Tools"))
 
         # Promise object with the new name
         self.app.collection.promise(name)
@@ -803,7 +803,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
         sorted_tools.sort(reverse=True)
 
         # Do job in background
-        proc = self.app.proc_container.new("Clearing Non-Copper areas.")
+        proc = self.app.proc_container.new(_("Clearing Non-Copper areas."))
 
         def initialize_rm(geo_obj, app_obj):
             assert isinstance(geo_obj, FlatCAMGeometry), \
@@ -821,7 +821,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
             # Generate area for each tool
             while sorted_tools:
                 tool = sorted_tools.pop(0)
-                self.app.inform.emit('[success] Non-Copper Rest Clearing with ToolDia = %s started.' % str(tool))
+                self.app.inform.emit(_('[success] Non-Copper Rest Clearing with ToolDia = %s started.') % str(tool))
 
                 tool_used = tool  - 1e-12
                 cleared_geo[:] = []
@@ -919,7 +919,7 @@ class NonCopperClear(FlatCAMTool, Gerber):
                 app_obj.new_object("geometry", name, initialize_rm)
             except Exception as e:
                 proc.done()
-                self.app.inform.emit('[ERROR_NOTCL] NCCTool.clear_non_copper_rest() --> %s' % str(e))
+                self.app.inform.emit(_('[ERROR_NOTCL] NCCTool.clear_non_copper_rest() --> %s') % str(e))
                 return
 
             if app_obj.poly_not_cleared is True:
@@ -927,8 +927,8 @@ class NonCopperClear(FlatCAMTool, Gerber):
                 # focus on Selected Tab
                 self.app.ui.notebook.setCurrentWidget(self.app.ui.selected_tab)
             else:
-                self.app.inform.emit('[ERROR_NOTCL] NCC Tool finished but could not clear the object '
-                                     'with current settings.')
+                self.app.inform.emit(_('[ERROR_NOTCL] NCC Tool finished but could not clear the object '
+                                     'with current settings.'))
                 # focus on Project Tab
                 self.app.ui.notebook.setCurrentWidget(self.app.ui.project_tab)
             proc.done()

flatcamTools/ToolPaint.py

@@ -5,7 +5,7 @@ from ObjectCollection import *
 
 class ToolPaint(FlatCAMTool, Gerber):
 
-    toolName = "Paint Area"
+    toolName = _("Paint Area")
 
     def __init__(self, app):
         self.app = app
@@ -41,19 +41,19 @@ class ToolPaint(FlatCAMTool, Gerber):
         self.object_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
         self.object_combo.setCurrentIndex(1)
 
-        self.object_label = QtWidgets.QLabel("Geometry:")
+        self.object_label = QtWidgets.QLabel(_("Geometry:"))
         self.object_label.setToolTip(
-            "Geometry object to be painted.                        "
+            _("Geometry object to be painted.                        ")
         )
         e_lab_0 = QtWidgets.QLabel('')
         form_layout.addRow(self.object_label, self.object_combo)
         form_layout.addRow(e_lab_0)
 
         #### Tools ####
-        self.tools_table_label = QtWidgets.QLabel('<b>Tools Table</b>')
+        self.tools_table_label = QtWidgets.QLabel('<b>%s</b>' % _('Tools Table'))
         self.tools_table_label.setToolTip(
-            "Tools pool from which the algorithm\n"
-            "will pick the ones used for painting."
+            _("Tools pool from which the algorithm\n"
+            "will pick the ones used for painting.")
         )
         self.tools_box.addWidget(self.tools_table_label)
 
@@ -61,25 +61,25 @@ class ToolPaint(FlatCAMTool, Gerber):
         self.tools_box.addWidget(self.tools_table)
 
         self.tools_table.setColumnCount(4)
-        self.tools_table.setHorizontalHeaderLabels(['#', 'Diameter', 'TT', ''])
+        self.tools_table.setHorizontalHeaderLabels(['#', _('Diameter'), 'TT', ''])
         self.tools_table.setColumnHidden(3, True)
         # self.tools_table.setSortingEnabled(False)
         # self.tools_table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
 
         self.tools_table.horizontalHeaderItem(0).setToolTip(
-            "This is the Tool Number.\n"
+            _("This is the Tool Number.\n"
             "Painting will start with the tool with the biggest diameter,\n"
             "continuing until there are no more tools.\n"
             "Only tools that create painting geometry will still be present\n"
             "in the resulting geometry. This is because with some tools\n"
-            "this function will not be able to create painting geometry."
+            "this function will not be able to create painting geometry.")
             )
         self.tools_table.horizontalHeaderItem(1).setToolTip(
-            "Tool Diameter. It's value (in current FlatCAM units) \n"
-            "is the cut width into the material.")
+            _("Tool Diameter. It's value (in current FlatCAM units) \n"
+            "is the cut width into the material."))
 
         self.tools_table.horizontalHeaderItem(2).setToolTip(
-            "The Tool Type (TT) can be:<BR>"
+            _("The Tool Type (TT) can be:<BR>"
             "- <B>Circular</B> with 1 ... 4 teeth -> it is informative only. Being circular, <BR>"
             "the cut width in material is exactly the tool diameter.<BR>"
             "- <B>Ball</B> -> informative only and make reference to the Ball type endmill.<BR>"
@@ -89,7 +89,7 @@ class ToolPaint(FlatCAMTool, Gerber):
             "as the cut width into material will be equal with the value in the Tool Diameter "
             "column of this table.<BR>"
             "Choosing the <B>V-Shape</B> Tool Type automatically will select the Operation Type "
-            "in the resulting geometry as Isolation.")
+            "in the resulting geometry as Isolation."))
 
         self.empty_label = QtWidgets.QLabel('')
         self.tools_box.addWidget(self.empty_label)
@@ -98,9 +98,9 @@ class ToolPaint(FlatCAMTool, Gerber):
         hlay = QtWidgets.QHBoxLayout()
         self.tools_box.addLayout(hlay)
 
-        self.addtool_entry_lbl = QtWidgets.QLabel('<b>Tool Dia:</b>')
+        self.addtool_entry_lbl = QtWidgets.QLabel('<b>%s:</b>' % _('Tool Dia'))
         self.addtool_entry_lbl.setToolTip(
-            "Diameter for the new tool."
+            _("Diameter for the new tool.")
         )
         self.addtool_entry = FCEntry()
 
@@ -112,10 +112,10 @@ class ToolPaint(FlatCAMTool, Gerber):
         grid2 = QtWidgets.QGridLayout()
         self.tools_box.addLayout(grid2)
 
-        self.addtool_btn = QtWidgets.QPushButton('Add')
+        self.addtool_btn = QtWidgets.QPushButton(_('Add'))
         self.addtool_btn.setToolTip(
-            "Add a new tool to the Tool Table\n"
-            "with the diameter specified above."
+            _("Add a new tool to the Tool Table\n"
+            "with the diameter specified above.")
         )
 
         # self.copytool_btn = QtWidgets.QPushButton('Copy')
@@ -124,10 +124,10 @@ class ToolPaint(FlatCAMTool, Gerber):
         #     "by first selecting a row in the Tool Table."
         # )
 
-        self.deltool_btn = QtWidgets.QPushButton('Delete')
+        self.deltool_btn = QtWidgets.QPushButton(_('Delete'))
         self.deltool_btn.setToolTip(
-            "Delete a selection of tools in the Tool Table\n"
-            "by first selecting a row(s) in the Tool Table."
+            _("Delete a selection of tools in the Tool Table\n"
+            "by first selecting a row(s) in the Tool Table.")
         )
 
         grid2.addWidget(self.addtool_btn, 0, 0)
@@ -141,9 +141,9 @@ class ToolPaint(FlatCAMTool, Gerber):
         self.tools_box.addLayout(grid3)
 
         # Overlap
-        ovlabel = QtWidgets.QLabel('Overlap:')
+        ovlabel = QtWidgets.QLabel(_('Overlap:'))
         ovlabel.setToolTip(
-            "How much (fraction) of the tool width to overlap each tool pass.\n"
+            _("How much (fraction) of the tool width to overlap each tool pass.\n"
             "Example:\n"
             "A value here of 0.25 means 25% from the tool diameter found above.\n\n"
             "Adjust the value starting with lower values\n"
@@ -151,30 +151,30 @@ class ToolPaint(FlatCAMTool, Gerber):
             "not painted.\n"
             "Lower values = faster processing, faster execution on PCB.\n"
             "Higher values = slow processing and slow execution on CNC\n"
-            "due of too many paths."
+            "due of too many paths.")
         )
         grid3.addWidget(ovlabel, 1, 0)
         self.paintoverlap_entry = FCEntry()
         grid3.addWidget(self.paintoverlap_entry, 1, 1)
 
         # Margin
-        marginlabel = QtWidgets.QLabel('Margin:')
+        marginlabel = QtWidgets.QLabel(_('Margin:'))
         marginlabel.setToolTip(
-            "Distance by which to avoid\n"
+            _("Distance by which to avoid\n"
             "the edges of the polygon to\n"
-            "be painted."
+            "be painted.")
         )
         grid3.addWidget(marginlabel, 2, 0)
         self.paintmargin_entry = FCEntry()
         grid3.addWidget(self.paintmargin_entry, 2, 1)
 
         # Method
-        methodlabel = QtWidgets.QLabel('Method:')
+        methodlabel = QtWidgets.QLabel(_('Method:'))
         methodlabel.setToolTip(
-            "Algorithm for non-copper clearing:<BR>"
+            _("Algorithm for non-copper clearing:<BR>"
             "<B>Standard</B>: Fixed step inwards.<BR>"
             "<B>Seed-based</B>: Outwards from seed.<BR>"
-            "<B>Line-based</B>: Parallel lines."
+            "<B>Line-based</B>: Parallel lines.")
         )
         grid3.addWidget(methodlabel, 3, 0)
         self.paintmethod_combo = RadioSet([
@@ -185,45 +185,45 @@ class ToolPaint(FlatCAMTool, Gerber):
         grid3.addWidget(self.paintmethod_combo, 3, 1)
 
         # Connect lines
-        pathconnectlabel = QtWidgets.QLabel("Connect:")
+        pathconnectlabel = QtWidgets.QLabel(_("Connect:"))
         pathconnectlabel.setToolTip(
-            "Draw lines between resulting\n"
-            "segments to minimize tool lifts."
+            _("Draw lines between resulting\n"
+            "segments to minimize tool lifts.")
         )
         grid3.addWidget(pathconnectlabel, 4, 0)
         self.pathconnect_cb = FCCheckBox()
         grid3.addWidget(self.pathconnect_cb, 4, 1)
 
-        contourlabel = QtWidgets.QLabel("Contour:")
+        contourlabel = QtWidgets.QLabel(_("Contour:"))
         contourlabel.setToolTip(
-            "Cut around the perimeter of the polygon\n"
-            "to trim rough edges."
+            _("Cut around the perimeter of the polygon\n"
+            "to trim rough edges.")
         )
         grid3.addWidget(contourlabel, 5, 0)
         self.paintcontour_cb = FCCheckBox()
         grid3.addWidget(self.paintcontour_cb, 5, 1)
 
-        restlabel = QtWidgets.QLabel("Rest M.:")
+        restlabel = QtWidgets.QLabel(_("Rest M.:"))
         restlabel.setToolTip(
-            "If checked, use 'rest machining'.\n"
+            _("If checked, use 'rest machining'.\n"
             "Basically it will clear copper outside PCB features,\n"
             "using the biggest tool and continue with the next tools,\n"
             "from bigger to smaller, to clear areas of copper that\n"
             "could not be cleared by previous tool, until there is\n"
             "no more copper to clear or there are no more tools.\n\n"
-            "If not checked, use the standard algorithm."
+            "If not checked, use the standard algorithm.")
         )
         grid3.addWidget(restlabel, 6, 0)
         self.rest_cb = FCCheckBox()
         grid3.addWidget(self.rest_cb, 6, 1)
 
         # Polygon selection
-        selectlabel = QtWidgets.QLabel('Selection:')
+        selectlabel = QtWidgets.QLabel(_('Selection:'))
         selectlabel.setToolTip(
-            "How to select the polygons to paint.<BR>"
+            _("How to select the polygons to paint.<BR>"
             "Options:<BR>"
             "- <B>Single</B>: left mouse click on the polygon to be painted.<BR>"
-            "- <B>All</B>: paint all polygons."
+            "- <B>All</B>: paint all polygons.")
         )
         grid3.addWidget(selectlabel, 7, 0)
         # grid3 = QtWidgets.QGridLayout()
@@ -235,13 +235,13 @@ class ToolPaint(FlatCAMTool, Gerber):
         grid3.addWidget(self.selectmethod_combo, 7, 1)
 
         # GO Button
-        self.generate_paint_button = QtWidgets.QPushButton('Create Paint Geometry')
+        self.generate_paint_button = QtWidgets.QPushButton(_('Create Paint Geometry'))
         self.generate_paint_button.setToolTip(
-            "After clicking here, click inside<BR>"
+            _("After clicking here, click inside<BR>"
             "the polygon you wish to be painted if <B>Single</B> is selected.<BR>"
             "If <B>All</B>  is selected then the Paint will start after click.<BR>"
             "A new Geometry object with the tool<BR>"
-            "paths will be created."
+            "paths will be created.")
         )
         self.tools_box.addWidget(self.generate_paint_button)
 
@@ -318,7 +318,7 @@ class ToolPaint(FlatCAMTool, Gerber):
         FlatCAMTool.run(self)
         self.set_tool_ui()
 
-        self.app.ui.notebook.setTabText(2, "Paint Tool")
+        self.app.ui.notebook.setTabText(2, _("Paint Tool"))
 
     def on_radio_selection(self):
         if self.selectmethod_combo.get_value() == 'single':
@@ -515,13 +515,13 @@ class ToolPaint(FlatCAMTool, Gerber):
                 try:
                     tool_dia = float(self.addtool_entry.get_value().replace(',', '.'))
                 except ValueError:
-                    self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                         "use a number.")
+                    self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                         "use a number."))
                     return
 
             if tool_dia is None:
                 self.build_ui()
-                self.app.inform.emit("[WARNING_NOTCL] Please enter a tool diameter to add, in Float format.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Please enter a tool diameter to add, in Float format."))
                 return
 
         # construct a list of all 'tooluid' in the self.tools
@@ -545,12 +545,12 @@ class ToolPaint(FlatCAMTool, Gerber):
 
         if float('%.4f' % tool_dia) in tool_dias:
             if muted is None:
-                self.app.inform.emit("[WARNING_NOTCL]Adding tool cancelled. Tool already in Tool Table.")
+                self.app.inform.emit(_("[WARNING_NOTCL]Adding tool cancelled. Tool already in Tool Table."))
             self.tools_table.itemChanged.connect(self.on_tool_edit)
             return
         else:
             if muted is None:
-                self.app.inform.emit("[success] New tool added to Tool Table.")
+                self.app.inform.emit(_("[success] New tool added to Tool Table."))
             self.paint_tools.update({
                 int(self.tooluid): {
                     'tooldia': float('%.4f' % tool_dia),
@@ -585,15 +585,15 @@ class ToolPaint(FlatCAMTool, Gerber):
                 try:
                     new_tool_dia = float(self.tools_table.item(row, 1).text().replace(',', '.'))
                 except ValueError:
-                    self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                         "use a number.")
+                    self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                         "use a number."))
                     return
             tooluid = int(self.tools_table.item(row, 3).text())
 
             # identify the tool that was edited and get it's tooluid
             if new_tool_dia not in tool_dias:
                 self.paint_tools[tooluid]['tooldia'] = new_tool_dia
-                self.app.inform.emit("[success] Tool from Tool Table was edited.")
+                self.app.inform.emit(_("[success] Tool from Tool Table was edited."))
                 self.build_ui()
                 return
             else:
@@ -604,7 +604,7 @@ class ToolPaint(FlatCAMTool, Gerber):
                         break
                 restore_dia_item = self.tools_table.item(row, 1)
                 restore_dia_item.setText(str(old_tool_dia))
-                self.app.inform.emit("[WARNING_NOTCL] Edit cancelled. New diameter value is already in the Tool Table.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Edit cancelled. New diameter value is already in the Tool Table."))
         self.build_ui()
 
     # def on_tool_copy(self, all=None):
@@ -701,18 +701,18 @@ class ToolPaint(FlatCAMTool, Gerber):
                     self.paint_tools.pop(t, None)
 
         except AttributeError:
-            self.app.inform.emit("[WARNING_NOTCL]Delete failed. Select a tool to delete.")
+            self.app.inform.emit(_("[WARNING_NOTCL]Delete failed. Select a tool to delete."))
             return
         except Exception as e:
             log.debug(str(e))
 
-        self.app.inform.emit("[success] Tool(s) deleted from Tool Table.")
+        self.app.inform.emit(_("[success] Tool(s) deleted from Tool Table."))
         self.build_ui()
 
     def on_paint_button_click(self):
-        self.app.report_usage("geometry_on_paint_button")
+        self.app.report_usage(_("geometry_on_paint_button"))
 
-        self.app.inform.emit("[WARNING_NOTCL]Click inside the desired polygon.")
+        self.app.inform.emit(_("[WARNING_NOTCL]Click inside the desired polygon."))
         try:
             overlap = float(self.paintoverlap_entry.get_value())
         except ValueError:
@@ -720,8 +720,8 @@ class ToolPaint(FlatCAMTool, Gerber):
             try:
                 overlap = float(self.paintoverlap_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         connect = self.pathconnect_cb.get_value()
@@ -734,17 +734,17 @@ class ToolPaint(FlatCAMTool, Gerber):
         try:
             self.paint_obj = self.app.collection.get_by_name(str(self.obj_name))
         except:
-            self.app.inform.emit("[ERROR_NOTCL]Could not retrieve object: %s" % self.obj_name)
+            self.app.inform.emit(_("[ERROR_NOTCL]Could not retrieve object: %s") % self.obj_name)
             return
 
         if self.paint_obj is None:
-            self.app.inform.emit("[ERROR_NOTCL]Object not found: %s" % self.paint_obj)
+            self.app.inform.emit(_("[ERROR_NOTCL]Object not found: %s") % self.paint_obj)
             return
 
         # test if the Geometry Object is multigeo and return Fail if True because
         # for now Paint don't work on MultiGeo
         if self.paint_obj.multigeo is True:
-            self.app.inform.emit("[ERROR_NOTCL] Can't do Paint on MultiGeo geometries ...")
+            self.app.inform.emit(_("[ERROR_NOTCL] Can't do Paint on MultiGeo geometries ..."))
             return 'Fail'
 
         o_name = '%s_multitool_paint' % (self.obj_name)
@@ -757,7 +757,7 @@ class ToolPaint(FlatCAMTool, Gerber):
                                 contour=contour)
 
         if select_method == "single":
-            self.app.inform.emit("[WARNING_NOTCL]Click inside the desired polygon.")
+            self.app.inform.emit(_("[WARNING_NOTCL]Click inside the desired polygon."))
 
             # use the first tool in the tool table; get the diameter
             tooldia = float('%.4f' % float(self.tools_table.item(0, 1).text()))
@@ -766,7 +766,7 @@ class ToolPaint(FlatCAMTool, Gerber):
             def doit(event):
                 # do paint single only for left mouse clicks
                 if event.button == 1:
-                    self.app.inform.emit("Painting polygon...")
+                    self.app.inform.emit(_("Painting polygon..."))
                     self.app.plotcanvas.vis_disconnect('mouse_press', doit)
                     pos = self.app.plotcanvas.vispy_canvas.translate_coords(event.pos)
                     self.paint_poly(self.paint_obj,
@@ -811,17 +811,17 @@ class ToolPaint(FlatCAMTool, Gerber):
             try:
                 paint_margin = float(self.paintmargin_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         # No polygon?
         if poly is None:
             self.app.log.warning('No polygon found.')
-            self.app.inform.emit('[WARNING] No polygon found.')
+            self.app.inform.emit(_('[WARNING] No polygon found.'))
             return
 
-        proc = self.app.proc_container.new("Painting polygon.")
+        proc = self.app.proc_container.new(_("Painting polygon."))
 
         name = outname if outname else self.obj_name + "_paint"
 
@@ -863,7 +863,7 @@ class ToolPaint(FlatCAMTool, Gerber):
                     geo_obj.solid_geometry += list(cp.get_objects())
                     return cp
                 else:
-                    self.app.inform.emit('[ERROR_NOTCL] Geometry could not be painted completely')
+                    self.app.inform.emit(_('[ERROR_NOTCL] Geometry could not be painted completely'))
                     return None
 
             geo_obj.solid_geometry = []
@@ -889,8 +889,8 @@ class ToolPaint(FlatCAMTool, Gerber):
             except Exception as e:
                 log.debug("Could not Paint the polygons. %s" % str(e))
                 self.app.inform.emit(
-                    "[ERROR] Could not do Paint. Try a different combination of parameters. "
-                    "Or a different strategy of paint\n%s" % str(e))
+                    _("[ERROR] Could not do Paint. Try a different combination of parameters. "
+                    "Or a different strategy of paint\n%s") % str(e))
                 return
 
             if cp is not None:
@@ -931,13 +931,13 @@ class ToolPaint(FlatCAMTool, Gerber):
                 app_obj.new_object("geometry", name, gen_paintarea)
             except Exception as e:
                 proc.done()
-                self.app.inform.emit('[ERROR_NOTCL] PaintTool.paint_poly() --> %s' % str(e))
+                self.app.inform.emit(_('[ERROR_NOTCL] PaintTool.paint_poly() --> %s') % str(e))
                 return
             proc.done()
             # focus on Selected Tab
             self.app.ui.notebook.setCurrentWidget(self.app.ui.selected_tab)
 
-        self.app.inform.emit("Polygon Paint started ...")
+        self.app.inform.emit(_("Polygon Paint started ..."))
 
         # Promise object with the new name
         self.app.collection.promise(name)
@@ -966,11 +966,11 @@ class ToolPaint(FlatCAMTool, Gerber):
             try:
                 paint_margin = float(self.paintmargin_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
-        proc = self.app.proc_container.new("Painting polygon.")
+        proc = self.app.proc_container.new(_("Painting polygon..."))
         name = outname if outname else self.obj_name + "_paint"
         over = overlap
         conn = connect
@@ -1085,8 +1085,8 @@ class ToolPaint(FlatCAMTool, Gerber):
                     except Exception as e:
                         log.debug("Could not Paint the polygons. %s" % str(e))
                         self.app.inform.emit(
-                            "[ERROR] Could not do Paint All. Try a different combination of parameters. "
-                            "Or a different Method of paint\n%s" % str(e))
+                            _("[ERROR] Could not do Paint All. Try a different combination of parameters. "
+                            "Or a different Method of paint\n%s") % str(e))
                         return
 
                 # add the solid_geometry to the current too in self.paint_tools dictionary and then reset the
@@ -1109,16 +1109,16 @@ class ToolPaint(FlatCAMTool, Gerber):
                 if geo_obj.tools[tooluid]['solid_geometry']:
                     has_solid_geo += 1
             if has_solid_geo == 0:
-                self.app.inform.emit("[ERROR] There is no Painting Geometry in the file.\n"
+                self.app.inform.emit(_("[ERROR] There is no Painting Geometry in the file.\n"
                                       "Usually it means that the tool diameter is too big for the painted geometry.\n"
-                                      "Change the painting parameters and try again.")
+                                      "Change the painting parameters and try again."))
                 return
 
             # Experimental...
             # print("Indexing...", end=' ')
             # geo_obj.make_index()
 
-            self.app.inform.emit("[success] Paint All Done.")
+            self.app.inform.emit(_("[success] Paint All Done."))
 
         # Initializes the new geometry object
         def gen_paintarea_rest_machining(geo_obj, app_obj):
@@ -1174,8 +1174,8 @@ class ToolPaint(FlatCAMTool, Gerber):
                     except Exception as e:
                         log.debug("Could not Paint the polygons. %s" % str(e))
                         self.app.inform.emit(
-                            "[ERROR] Could not do Paint All. Try a different combination of parameters. "
-                            "Or a different Method of paint\n%s" % str(e))
+                            _("[ERROR] Could not do Paint All. Try a different combination of parameters. "
+                            "Or a different Method of paint\n%s") % str(e))
                         return
 
                 # find the tooluid associated with the current tool_dia so we know where to add the tool solid_geometry
@@ -1204,16 +1204,16 @@ class ToolPaint(FlatCAMTool, Gerber):
                 if geo_obj.tools[tooluid]['solid_geometry']:
                     has_solid_geo += 1
             if has_solid_geo == 0:
-                self.app.inform.emit("[ERROR_NOTCL] There is no Painting Geometry in the file.\n"
+                self.app.inform.emit(_("[ERROR_NOTCL] There is no Painting Geometry in the file.\n"
                                       "Usually it means that the tool diameter is too big for the painted geometry.\n"
-                                      "Change the painting parameters and try again.")
+                                      "Change the painting parameters and try again."))
                 return
 
             # Experimental...
             # print("Indexing...", end=' ')
             # geo_obj.make_index()
 
-            self.app.inform.emit("[success] Paint All with Rest-Machining Done.")
+            self.app.inform.emit(_("[success] Paint All with Rest-Machining done."))
 
         def job_thread(app_obj):
             try:
@@ -1229,7 +1229,7 @@ class ToolPaint(FlatCAMTool, Gerber):
             # focus on Selected Tab
             self.app.ui.notebook.setCurrentWidget(self.app.ui.selected_tab)
 
-        self.app.inform.emit("Polygon Paint started ...")
+        self.app.inform.emit(_("Polygon Paint started ..."))
 
         # Promise object with the new name
         self.app.collection.promise(name)

flatcamTools/ToolPanelize.py

@@ -6,7 +6,7 @@ import time
 
 class Panelize(FlatCAMTool):
 
-    toolName = "Panelize PCB"
+    toolName = _("Panelize PCB")
 
     def __init__(self, app):
         super(Panelize, self).__init__(self)
@@ -37,12 +37,12 @@ class Panelize(FlatCAMTool):
         self.type_obj_combo.setItemIcon(1, QtGui.QIcon("share/drill16.png"))
         self.type_obj_combo.setItemIcon(2, QtGui.QIcon("share/geometry16.png"))
 
-        self.type_obj_combo_label = QtWidgets.QLabel("Object Type:")
+        self.type_obj_combo_label = QtWidgets.QLabel(_("Object Type:"))
         self.type_obj_combo_label.setToolTip(
-            "Specify the type of object to be panelized\n"
+            _("Specify the type of object to be panelized\n"
             "It can be of type: Gerber, Excellon or Geometry.\n"
             "The selection here decide the type of objects that will be\n"
-            "in the Object combobox."
+            "in the Object combobox.")
         )
         form_layout.addRow(self.type_obj_combo_label, self.type_obj_combo)
 
@@ -52,10 +52,10 @@ class Panelize(FlatCAMTool):
         self.object_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
         self.object_combo.setCurrentIndex(1)
 
-        self.object_label = QtWidgets.QLabel("Object:")
+        self.object_label = QtWidgets.QLabel(_("Object:"))
         self.object_label.setToolTip(
-            "Object to be panelized. This means that it will\n"
-            "be duplicated in an array of rows and columns."
+            _("Object to be panelized. This means that it will\n"
+            "be duplicated in an array of rows and columns.")
         )
         form_layout.addRow(self.object_label, self.object_combo)
 
@@ -70,12 +70,12 @@ class Panelize(FlatCAMTool):
         self.type_box_combo.setItemIcon(0, QtGui.QIcon("share/flatcam_icon16.png"))
         self.type_box_combo.setItemIcon(2, QtGui.QIcon("share/geometry16.png"))
 
-        self.type_box_combo_label = QtWidgets.QLabel("Box Type:")
+        self.type_box_combo_label = QtWidgets.QLabel(_("Box Type:"))
         self.type_box_combo_label.setToolTip(
-            "Specify the type of object to be used as an container for\n"
+            _("Specify the type of object to be used as an container for\n"
             "panelization. It can be: Gerber or Geometry type.\n"
             "The selection here decide the type of objects that will be\n"
-            "in the Box Object combobox."
+            "in the Box Object combobox.")
         )
         form_layout.addRow(self.type_box_combo_label, self.type_box_combo)
 
@@ -85,83 +85,83 @@ class Panelize(FlatCAMTool):
         self.box_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))
         self.box_combo.setCurrentIndex(1)
 
-        self.box_combo_label = QtWidgets.QLabel("Box Object:")
+        self.box_combo_label = QtWidgets.QLabel(_("Box Object:"))
         self.box_combo_label.setToolTip(
-            "The actual object that is used a container for the\n "
-            "selected object that is to be panelized."
+            _("The actual object that is used a container for the\n "
+            "selected object that is to be panelized.")
         )
         form_layout.addRow(self.box_combo_label, self.box_combo)
 
         ## Spacing Columns
         self.spacing_columns = FCEntry()
-        self.spacing_columns_label = QtWidgets.QLabel("Spacing cols:")
+        self.spacing_columns_label = QtWidgets.QLabel(_("Spacing cols:"))
         self.spacing_columns_label.setToolTip(
-            "Spacing between columns of the desired panel.\n"
-            "In current units."
+            _("Spacing between columns of the desired panel.\n"
+            "In current units.")
         )
         form_layout.addRow(self.spacing_columns_label, self.spacing_columns)
 
         ## Spacing Rows
         self.spacing_rows = FCEntry()
-        self.spacing_rows_label = QtWidgets.QLabel("Spacing rows:")
+        self.spacing_rows_label = QtWidgets.QLabel(_("Spacing rows:"))
         self.spacing_rows_label.setToolTip(
-            "Spacing between rows of the desired panel.\n"
-            "In current units."
+            _("Spacing between rows of the desired panel.\n"
+            "In current units.")
         )
         form_layout.addRow(self.spacing_rows_label, self.spacing_rows)
 
         ## Columns
         self.columns = FCEntry()
-        self.columns_label = QtWidgets.QLabel("Columns:")
+        self.columns_label = QtWidgets.QLabel(_("Columns:"))
         self.columns_label.setToolTip(
-            "Number of columns of the desired panel"
+            _("Number of columns of the desired panel")
         )
         form_layout.addRow(self.columns_label, self.columns)
 
         ## Rows
         self.rows = FCEntry()
-        self.rows_label = QtWidgets.QLabel("Rows:")
+        self.rows_label = QtWidgets.QLabel(_("Rows:"))
         self.rows_label.setToolTip(
-            "Number of rows of the desired panel"
+            _("Number of rows of the desired panel")
         )
         form_layout.addRow(self.rows_label, self.rows)
 
         ## Type of resulting Panel object
         self.panel_type_radio = RadioSet([{'label': 'Gerber', 'value': 'gerber'},
                                      {'label': 'Geometry', 'value': 'geometry'}])
-        self.panel_type_label = QtWidgets.QLabel("Panel Type:")
+        self.panel_type_label = QtWidgets.QLabel(_("Panel Type:"))
         self.panel_type_label.setToolTip(
-            "Choose the type of object for the panel object:\n"
+            _("Choose the type of object for the panel object:\n"
             "- Geometry\n"
-            "- Gerber"
+            "- Gerber")
         )
         form_layout.addRow(self.panel_type_label)
         form_layout.addRow(self.panel_type_radio)
 
         ## Constrains
-        self.constrain_cb = FCCheckBox("Constrain panel within:")
+        self.constrain_cb = FCCheckBox(_("Constrain panel within:"))
         self.constrain_cb.setToolTip(
-            "Area define by DX and DY within to constrain the panel.\n"
+            _("Area define by DX and DY within to constrain the panel.\n"
             "DX and DY values are in current units.\n"
             "Regardless of how many columns and rows are desired,\n"
             "the final panel will have as many columns and rows as\n"
-            "they fit completely within selected area."
+            "they fit completely within selected area.")
         )
         form_layout.addRow(self.constrain_cb)
 
         self.x_width_entry = FCEntry()
-        self.x_width_lbl = QtWidgets.QLabel("Width (DX):")
+        self.x_width_lbl = QtWidgets.QLabel(_("Width (DX):"))
         self.x_width_lbl.setToolTip(
-            "The width (DX) within which the panel must fit.\n"
-            "In current units."
+            _("The width (DX) within which the panel must fit.\n"
+            "In current units.")
         )
         form_layout.addRow(self.x_width_lbl, self.x_width_entry)
 
         self.y_height_entry = FCEntry()
-        self.y_height_lbl = QtWidgets.QLabel("Height (DY):")
+        self.y_height_lbl = QtWidgets.QLabel(_("Height (DY):"))
         self.y_height_lbl.setToolTip(
-            "The height (DY)within which the panel must fit.\n"
-            "In current units."
+            _("The height (DY)within which the panel must fit.\n"
+            "In current units.")
         )
         form_layout.addRow(self.y_height_lbl, self.y_height_entry)
 
@@ -173,11 +173,11 @@ class Panelize(FlatCAMTool):
         self.layout.addLayout(hlay_2)
 
         hlay_2.addStretch()
-        self.panelize_object_button = QtWidgets.QPushButton("Panelize Object")
+        self.panelize_object_button = QtWidgets.QPushButton(_("Panelize Object"))
         self.panelize_object_button.setToolTip(
-            "Panelize the specified object around the specified box.\n"
+            _("Panelize the specified object around the specified box.\n"
             "In other words it creates multiple copies of the source object,\n"
-            "arranged in a 2D array of rows and columns."
+            "arranged in a 2D array of rows and columns.")
         )
         hlay_2.addWidget(self.panelize_object_button)
 
@@ -271,13 +271,13 @@ class Panelize(FlatCAMTool):
         try:
             obj = self.app.collection.get_by_name(str(name))
         except:
-            self.app.inform.emit("[ERROR_NOTCL]Could not retrieve object: %s" % name)
+            self.app.inform.emit(_("[ERROR_NOTCL]Could not retrieve object: %s") % name)
             return "Could not retrieve object: %s" % name
 
         panel_obj = obj
 
         if panel_obj is None:
-            self.app.inform.emit("[ERROR_NOTCL]Object not found: %s" % panel_obj)
+            self.app.inform.emit(_("[ERROR_NOTCL]Object not found: %s") % panel_obj)
             return "Object not found: %s" % panel_obj
 
         boxname = self.box_combo.currentText()
@@ -285,11 +285,11 @@ class Panelize(FlatCAMTool):
         try:
             box = self.app.collection.get_by_name(boxname)
         except:
-            self.app.inform.emit("[ERROR_NOTCL]Could not retrieve object: %s" % boxname)
+            self.app.inform.emit(_("[ERROR_NOTCL]Could not retrieve object: %s") % boxname)
             return "Could not retrieve object: %s" % boxname
 
         if box is None:
-            self.app.inform.emit("[WARNING]No object Box. Using instead %s" % panel_obj)
+            self.app.inform.emit(_("[WARNING]No object Box. Using instead %s") % panel_obj)
             box = panel_obj
 
         self.outname = name + '_panelized'
@@ -301,8 +301,8 @@ class Panelize(FlatCAMTool):
             try:
                 spacing_columns = float(self.spacing_columns.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         spacing_columns = spacing_columns if spacing_columns is not None else 0
 
@@ -313,8 +313,8 @@ class Panelize(FlatCAMTool):
             try:
                 spacing_rows = float(self.spacing_rows.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         spacing_rows = spacing_rows if spacing_rows is not None else 0
 
@@ -326,8 +326,8 @@ class Panelize(FlatCAMTool):
                 rows = float(self.rows.get_value().replace(',', '.'))
                 rows = int(rows)
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         rows = rows if rows is not None else 1
 
@@ -339,8 +339,8 @@ class Panelize(FlatCAMTool):
                 columns = float(self.columns.get_value().replace(',', '.'))
                 columns = int(columns)
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
         columns = columns if columns is not None else 1
 
@@ -351,8 +351,8 @@ class Panelize(FlatCAMTool):
             try:
                 constrain_dx = float(self.x_width_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         try:
@@ -362,15 +362,15 @@ class Panelize(FlatCAMTool):
             try:
                 constrain_dy = float(self.y_height_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                     "use a number."))
                 return
 
         panel_type = str(self.panel_type_radio.get_value())
 
 
         if 0 in {columns, rows}:
-            self.app.inform.emit("[ERROR_NOTCL]Columns or Rows are zero value. Change them to a positive integer.")
+            self.app.inform.emit(_("[ERROR_NOTCL]Columns or Rows are zero value. Change them to a positive integer."))
             return "Columns or Rows are zero value. Change them to a positive integer."
 
         xmin, ymin, xmax, ymax = box.bounds()
@@ -474,7 +474,7 @@ class Panelize(FlatCAMTool):
 
         def panelize_2():
             if panel_obj is not None:
-                self.app.inform.emit("Generating panel ... Please wait.")
+                self.app.inform.emit(_("Generating panel ... Please wait."))
 
                 self.app.progress.emit(0)
 
@@ -577,18 +577,18 @@ class Panelize(FlatCAMTool):
                                         plot=True, autoselected=True)
 
         if self.constrain_flag is False:
-            self.app.inform.emit("[success]Panel done...")
+            self.app.inform.emit(_("[success]Panel done..."))
         else:
             self.constrain_flag = False
-            self.app.inform.emit("[WARNING] Too big for the constrain area. Final panel has %s columns and %s rows" %
+            self.app.inform.emit(_("[WARNING] Too big for the constrain area. Final panel has %s columns and %s rows") %
                                  (columns, rows))
 
-        proc = self.app.proc_container.new("Generating panel ... Please wait.")
+        proc = self.app.proc_container.new(_("Generating panel ... Please wait."))
 
         def job_thread(app_obj):
             try:
                 panelize_2()
-                self.app.inform.emit("[success]Panel created successfully.")
+                self.app.inform.emit(_("[success]Panel created successfully."))
             except Exception as e:
                 proc.done()
                 log.debug(str(e))

flatcamTools/ToolProperties.py

@@ -6,7 +6,7 @@ from FlatCAMObj import *
 
 class Properties(FlatCAMTool):
 
-    toolName = "Properties"
+    toolName = _("Properties")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
@@ -80,15 +80,15 @@ class Properties(FlatCAMTool):
     def properties(self):
         obj_list = self.app.collection.get_selected()
         if not obj_list:
-            self.app.inform.emit("[ERROR_NOTCL] Properties Tool was not displayed. No object selected.")
-            self.app.ui.notebook.setTabText(2, "Tools")
+            self.app.inform.emit(_("[ERROR_NOTCL] Properties Tool was not displayed. No object selected."))
+            self.app.ui.notebook.setTabText(2, _("Tools"))
             self.properties_frame.hide()
             self.app.ui.notebook.setCurrentWidget(self.app.ui.project_tab)
             return
         for obj in obj_list:
             self.addItems(obj)
-            self.app.inform.emit("[success] Object Properties are displayed.")
-        self.app.ui.notebook.setTabText(2, "Properties Tool")
+            self.app.inform.emit(_("[success] Object Properties are displayed."))
+        self.app.ui.notebook.setTabText(2, _("Properties Tool"))
 
     def addItems(self, obj):
         parent = self.treeWidget.invisibleRootItem()

flatcamTools/ToolShell.py

@@ -58,9 +58,9 @@ class TermWidget(QWidget):
         self._edit.setTextColor(Qt.white)
         self._edit.setTextBackgroundColor(Qt.darkGreen)
         if detail is None:
-            self._edit.setPlainText("...proccessing...")
+            self._edit.setPlainText(_("...proccessing..."))
         else:
-            self._edit.setPlainText("...proccessing... [%s]" % detail)
+            self._edit.setPlainText(_("...proccessing... [%s]") % detail)
 
         self._edit.setDisabled(True)
         self._edit.setFocus()

flatcamTools/ToolSolderPaste.py

@@ -19,7 +19,7 @@ from io import StringIO
 
 
 class SolderPaste(FlatCAMTool):
-    toolName = "Solder Paste Tool"
+    toolName = _("Solder Paste Tool")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
@@ -47,15 +47,15 @@ class SolderPaste(FlatCAMTool):
 
         self.object_label = QtWidgets.QLabel("Gerber:   ")
         self.object_label.setToolTip(
-            "Gerber Solder paste object.                        "
+            _("Gerber Solder paste object.                        ")
         )
         obj_form_layout.addRow(self.object_label, self.obj_combo)
 
         #### Tools ####
-        self.tools_table_label = QtWidgets.QLabel('<b>Tools Table</b>')
+        self.tools_table_label = QtWidgets.QLabel('<b>%s</b>' % _('Tools Table'))
         self.tools_table_label.setToolTip(
-            "Tools pool from which the algorithm\n"
-            "will pick the ones used for dispensing solder paste."
+            _("Tools pool from which the algorithm\n"
+            "will pick the ones used for dispensing solder paste.")
         )
         self.layout.addWidget(self.tools_table_label)
 
@@ -63,29 +63,29 @@ class SolderPaste(FlatCAMTool):
         self.layout.addWidget(self.tools_table)
 
         self.tools_table.setColumnCount(3)
-        self.tools_table.setHorizontalHeaderLabels(['#', 'Diameter', ''])
+        self.tools_table.setHorizontalHeaderLabels(['#', _('Diameter'), ''])
         self.tools_table.setColumnHidden(2, True)
         self.tools_table.setSortingEnabled(False)
         # self.tools_table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
 
         self.tools_table.horizontalHeaderItem(0).setToolTip(
-            "This is the Tool Number.\n"
+            _("This is the Tool Number.\n"
             "The solder dispensing will start with the tool with the biggest \n"
             "diameter, continuing until there are no more Nozzle tools.\n"
             "If there are no longer tools but there are still pads not covered\n "
-            "with solder paste, the app will issue a warning message box."
+            "with solder paste, the app will issue a warning message box.")
             )
         self.tools_table.horizontalHeaderItem(1).setToolTip(
-            "Nozzle tool Diameter. It's value (in current FlatCAM units)\n"
-            "is the width of the solder paste dispensed.")
+           _( "Nozzle tool Diameter. It's value (in current FlatCAM units)\n"
+            "is the width of the solder paste dispensed."))
 
         #### Add a new Tool ####
         hlay_tools = QtWidgets.QHBoxLayout()
         self.layout.addLayout(hlay_tools)
 
-        self.addtool_entry_lbl = QtWidgets.QLabel('<b>New Nozzle Tool:</b>')
+        self.addtool_entry_lbl = QtWidgets.QLabel('<b>%s:</b>' % _('New Nozzle Tool'))
         self.addtool_entry_lbl.setToolTip(
-            "Diameter for the new Nozzle tool to add in the Tool Table"
+            _("Diameter for the new Nozzle tool to add in the Tool Table")
         )
         self.addtool_entry = FCEntry()
 
@@ -97,21 +97,21 @@ class SolderPaste(FlatCAMTool):
         grid0 = QtWidgets.QGridLayout()
         self.layout.addLayout(grid0)
 
-        self.addtool_btn = QtWidgets.QPushButton('Add')
+        self.addtool_btn = QtWidgets.QPushButton(_('Add'))
         self.addtool_btn.setToolTip(
-            "Add a new nozzle tool to the Tool Table\n"
-            "with the diameter specified above."
+            _("Add a new nozzle tool to the Tool Table\n"
+            "with the diameter specified above.")
         )
 
-        self.deltool_btn = QtWidgets.QPushButton('Delete')
+        self.deltool_btn = QtWidgets.QPushButton(_('Delete'))
         self.deltool_btn.setToolTip(
-            "Delete a selection of tools in the Tool Table\n"
-            "by first selecting a row(s) in the Tool Table."
+           _( "Delete a selection of tools in the Tool Table\n"
+            "by first selecting a row(s) in the Tool Table.")
         )
 
-        self.soldergeo_btn = QtWidgets.QPushButton("Generate Geo")
+        self.soldergeo_btn = QtWidgets.QPushButton(_("Generate Geo"))
         self.soldergeo_btn.setToolTip(
-            "Generate solder paste dispensing geometry."
+            _("Generate solder paste dispensing geometry.")
         )
 
         grid0.addWidget(self.addtool_btn, 0, 0)
@@ -124,13 +124,13 @@ class SolderPaste(FlatCAMTool):
         grid0_1 = QtWidgets.QGridLayout()
         self.layout.addLayout(grid0_1)
 
-        step1_lbl = QtWidgets.QLabel("<b>STEP 1:</b>")
+        step1_lbl = QtWidgets.QLabel("<b>%s:</b>" % _('STEP 1'))
         step1_lbl.setToolTip(
-            "First step is to select a number of nozzle tools for usage\n"
-            "and then optionally modify the GCode parameters bellow."
+            _("First step is to select a number of nozzle tools for usage\n"
+            "and then optionally modify the GCode parameters bellow.")
         )
-        step1_description_lbl = QtWidgets.QLabel("Select tools.\n"
-                                                 "Modify parameters.")
+        step1_description_lbl = QtWidgets.QLabel(_("Select tools.\n"
+                                                 "Modify parameters."))
 
         grid0_1.addWidget(step1_lbl, 0, 0, alignment=Qt.AlignTop)
         grid0_1.addWidget(step1_description_lbl, 0, 2, alignment=Qt.AlignBottom)
@@ -148,120 +148,120 @@ class SolderPaste(FlatCAMTool):
 
         # Z dispense start
         self.z_start_entry = FCEntry()
-        self.z_start_label = QtWidgets.QLabel("Z Dispense Start:")
+        self.z_start_label = QtWidgets.QLabel(_("Z Dispense Start:"))
         self.z_start_label.setToolTip(
-            "The height (Z) when solder paste dispensing starts."
+            _("The height (Z) when solder paste dispensing starts.")
         )
         self.gcode_form_layout.addRow(self.z_start_label, self.z_start_entry)
 
         # Z dispense
         self.z_dispense_entry = FCEntry()
-        self.z_dispense_label = QtWidgets.QLabel("Z Dispense:")
+        self.z_dispense_label = QtWidgets.QLabel(_("Z Dispense:"))
         self.z_dispense_label.setToolTip(
-            "The height (Z) when doing solder paste dispensing."
+            _("The height (Z) when doing solder paste dispensing.")
 
         )
         self.gcode_form_layout.addRow(self.z_dispense_label, self.z_dispense_entry)
 
         # Z dispense stop
         self.z_stop_entry = FCEntry()
-        self.z_stop_label = QtWidgets.QLabel("Z Dispense Stop:")
+        self.z_stop_label = QtWidgets.QLabel(_("Z Dispense Stop:"))
         self.z_stop_label.setToolTip(
-            "The height (Z) when solder paste dispensing stops."
+            _("The height (Z) when solder paste dispensing stops.")
         )
         self.gcode_form_layout.addRow(self.z_stop_label, self.z_stop_entry)
 
         # Z travel
         self.z_travel_entry = FCEntry()
-        self.z_travel_label = QtWidgets.QLabel("Z Travel:")
+        self.z_travel_label = QtWidgets.QLabel(_("Z Travel:"))
         self.z_travel_label.setToolTip(
-            "The height (Z) for travel between pads\n"
-            "(without dispensing solder paste)."
+           _( "The height (Z) for travel between pads\n"
+            "(without dispensing solder paste).")
         )
         self.gcode_form_layout.addRow(self.z_travel_label, self.z_travel_entry)
 
         # Z toolchange location
         self.z_toolchange_entry = FCEntry()
-        self.z_toolchange_label = QtWidgets.QLabel("Z Toolchange:")
+        self.z_toolchange_label = QtWidgets.QLabel(_("Z Toolchange:"))
         self.z_toolchange_label.setToolTip(
-            "The height (Z) for tool (nozzle) change."
+           _( "The height (Z) for tool (nozzle) change.")
         )
         self.gcode_form_layout.addRow(self.z_toolchange_label, self.z_toolchange_entry)
 
         # X,Y Toolchange location
         self.xy_toolchange_entry = FCEntry()
-        self.xy_toolchange_label = QtWidgets.QLabel("XY Toolchange:")
+        self.xy_toolchange_label = QtWidgets.QLabel(_("XY Toolchange:"))
         self.xy_toolchange_label.setToolTip(
-            "The X,Y location for tool (nozzle) change.\n"
-            "The format is (x, y) where x and y are real numbers."
+            _("The X,Y location for tool (nozzle) change.\n"
+            "The format is (x, y) where x and y are real numbers.")
         )
         self.gcode_form_layout.addRow(self.xy_toolchange_label, self.xy_toolchange_entry)
 
         # Feedrate X-Y
         self.frxy_entry = FCEntry()
-        self.frxy_label = QtWidgets.QLabel("Feedrate X-Y:")
+        self.frxy_label = QtWidgets.QLabel(_("Feedrate X-Y:"))
         self.frxy_label.setToolTip(
-            "Feedrate (speed) while moving on the X-Y plane."
+           _( "Feedrate (speed) while moving on the X-Y plane.")
         )
         self.gcode_form_layout.addRow(self.frxy_label, self.frxy_entry)
 
         # Feedrate Z
         self.frz_entry = FCEntry()
-        self.frz_label = QtWidgets.QLabel("Feedrate Z:")
+        self.frz_label = QtWidgets.QLabel(_("Feedrate Z:"))
         self.frz_label.setToolTip(
-            "Feedrate (speed) while moving vertically\n"
-            "(on Z plane)."
+            _("Feedrate (speed) while moving vertically\n"
+            "(on Z plane).")
         )
         self.gcode_form_layout.addRow(self.frz_label, self.frz_entry)
 
         # Feedrate Z Dispense
         self.frz_dispense_entry = FCEntry()
-        self.frz_dispense_label = QtWidgets.QLabel("Feedrate Z Dispense:")
+        self.frz_dispense_label = QtWidgets.QLabel(_("Feedrate Z Dispense:"))
         self.frz_dispense_label.setToolTip(
-            "Feedrate (speed) while moving up vertically\n"
-            " to Dispense position (on Z plane)."
+           _( "Feedrate (speed) while moving up vertically\n"
+            " to Dispense position (on Z plane).")
         )
         self.gcode_form_layout.addRow(self.frz_dispense_label, self.frz_dispense_entry)
 
         # Spindle Speed Forward
         self.speedfwd_entry = FCEntry()
-        self.speedfwd_label = QtWidgets.QLabel("Spindle Speed FWD:")
+        self.speedfwd_label = QtWidgets.QLabel(_("Spindle Speed FWD:"))
         self.speedfwd_label.setToolTip(
-            "The dispenser speed while pushing solder paste\n"
-            "through the dispenser nozzle."
+           _( "The dispenser speed while pushing solder paste\n"
+            "through the dispenser nozzle.")
         )
         self.gcode_form_layout.addRow(self.speedfwd_label, self.speedfwd_entry)
 
         # Dwell Forward
         self.dwellfwd_entry = FCEntry()
-        self.dwellfwd_label = QtWidgets.QLabel("Dwell FWD:")
+        self.dwellfwd_label = QtWidgets.QLabel(_("Dwell FWD:"))
         self.dwellfwd_label.setToolTip(
-            "Pause after solder dispensing."
+            _("Pause after solder dispensing.")
         )
         self.gcode_form_layout.addRow(self.dwellfwd_label, self.dwellfwd_entry)
 
         # Spindle Speed Reverse
         self.speedrev_entry = FCEntry()
-        self.speedrev_label = QtWidgets.QLabel("Spindle Speed REV:")
+        self.speedrev_label = QtWidgets.QLabel(_("Spindle Speed REV:"))
         self.speedrev_label.setToolTip(
-            "The dispenser speed while retracting solder paste\n"
-            "through the dispenser nozzle."
+           _( "The dispenser speed while retracting solder paste\n"
+            "through the dispenser nozzle.")
         )
         self.gcode_form_layout.addRow(self.speedrev_label, self.speedrev_entry)
 
         # Dwell Reverse
         self.dwellrev_entry = FCEntry()
-        self.dwellrev_label = QtWidgets.QLabel("Dwell REV:")
+        self.dwellrev_label = QtWidgets.QLabel(_("Dwell REV:"))
         self.dwellrev_label.setToolTip(
-            "Pause after solder paste dispenser retracted,\n"
-            "to allow pressure equilibrium."
+            _("Pause after solder paste dispenser retracted,\n"
+            "to allow pressure equilibrium.")
         )
         self.gcode_form_layout.addRow(self.dwellrev_label, self.dwellrev_entry)
 
         # Postprocessors
-        pp_label = QtWidgets.QLabel('PostProcessors:')
+        pp_label = QtWidgets.QLabel(_('PostProcessors:'))
         pp_label.setToolTip(
-            "Files that control the GCode generation."
+            _("Files that control the GCode generation.")
         )
 
         self.pp_combo = FCComboBox()
@@ -272,10 +272,10 @@ class SolderPaste(FlatCAMTool):
         grid1 = QtWidgets.QGridLayout()
         self.gcode_box.addLayout(grid1)
 
-        self.solder_gcode_btn = QtWidgets.QPushButton("Generate GCode")
+        self.solder_gcode_btn = QtWidgets.QPushButton(_("Generate GCode"))
         self.solder_gcode_btn.setToolTip(
-            "Generate GCode for Solder Paste dispensing\n"
-            "on PCB pads."
+           _( "Generate GCode for Solder Paste dispensing\n"
+            "on PCB pads.")
         )
 
         self.generation_frame = QtWidgets.QFrame()
@@ -290,10 +290,10 @@ class SolderPaste(FlatCAMTool):
         grid2 = QtWidgets.QGridLayout()
         self.generation_box.addLayout(grid2)
 
-        step2_lbl = QtWidgets.QLabel("<b>STEP 2:</b>")
+        step2_lbl = QtWidgets.QLabel("<b>%s</b>" % _('STEP 2:'))
         step2_lbl.setToolTip(
-            "Second step is to create a solder paste dispensing\n"
-            "geometry out of an Solder Paste Mask Gerber file."
+            _("Second step is to create a solder paste dispensing\n"
+            "geometry out of an Solder Paste Mask Gerber file.")
         )
         grid2.addWidget(step2_lbl, 0, 0)
         grid2.addWidget(self.soldergeo_btn, 0, 2)
@@ -308,24 +308,24 @@ class SolderPaste(FlatCAMTool):
         self.geo_obj_combo.setRootModelIndex(self.app.collection.index(2, 0, QtCore.QModelIndex()))
         self.geo_obj_combo.setCurrentIndex(1)
 
-        self.geo_object_label = QtWidgets.QLabel("Geo Result:")
+        self.geo_object_label = QtWidgets.QLabel(_("Geo Result:"))
         self.geo_object_label.setToolTip(
-            "Geometry Solder Paste object.\n"
+           _( "Geometry Solder Paste object.\n"
             "The name of the object has to end in:\n"
-            "'_solderpaste' as a protection."
+            "'_solderpaste' as a protection.")
         )
         geo_form_layout.addRow(self.geo_object_label, self.geo_obj_combo)
 
         grid3 = QtWidgets.QGridLayout()
         self.generation_box.addLayout(grid3)
 
-        step3_lbl = QtWidgets.QLabel("<b>STEP 3:</b>")
+        step3_lbl = QtWidgets.QLabel("<b>%s</b>" % _('STEP 3:'))
         step3_lbl.setToolTip(
-            "Third step is to select a solder paste dispensing geometry,\n"
+           _( "Third step is to select a solder paste dispensing geometry,\n"
             "and then generate a CNCJob object.\n\n"
             "REMEMBER: if you want to create a CNCJob with new parameters,\n"
             "first you need to generate a geometry with those new params,\n"
-            "and only after that you can generate an updated CNCJob."
+            "and only after that you can generate an updated CNCJob.")
         )
 
         grid3.addWidget(step3_lbl, 0, 0)
@@ -341,34 +341,34 @@ class SolderPaste(FlatCAMTool):
         self.cnc_obj_combo.setRootModelIndex(self.app.collection.index(3, 0, QtCore.QModelIndex()))
         self.cnc_obj_combo.setCurrentIndex(1)
 
-        self.cnc_object_label = QtWidgets.QLabel("CNC Result:")
+        self.cnc_object_label = QtWidgets.QLabel(_("CNC Result:"))
         self.cnc_object_label.setToolTip(
-            "CNCJob Solder paste object.\n"
+           _( "CNCJob Solder paste object.\n"
             "In order to enable the GCode save section,\n"
             "the name of the object has to end in:\n"
-            "'_solderpaste' as a protection."
+            "'_solderpaste' as a protection.")
         )
         cnc_form_layout.addRow(self.cnc_object_label, self.cnc_obj_combo)
 
         grid4 = QtWidgets.QGridLayout()
         self.generation_box.addLayout(grid4)
 
-        self.solder_gcode_view_btn = QtWidgets.QPushButton("View GCode")
+        self.solder_gcode_view_btn = QtWidgets.QPushButton(_("View GCode"))
         self.solder_gcode_view_btn.setToolTip(
-            "View the generated GCode for Solder Paste dispensing\n"
-            "on PCB pads."
+            _("View the generated GCode for Solder Paste dispensing\n"
+            "on PCB pads.")
         )
 
-        self.solder_gcode_save_btn = QtWidgets.QPushButton("Save GCode")
+        self.solder_gcode_save_btn = QtWidgets.QPushButton(_("Save GCode"))
         self.solder_gcode_save_btn.setToolTip(
-            "Save the generated GCode for Solder Paste dispensing\n"
-            "on PCB pads, to a file."
+           _( "Save the generated GCode for Solder Paste dispensing\n"
+            "on PCB pads, to a file.")
         )
 
-        step4_lbl = QtWidgets.QLabel("<b>STEP 4:</b>")
+        step4_lbl = QtWidgets.QLabel("<b>%s</b>" % _('STEP 4:'))
         step4_lbl.setToolTip(
-            "Fourth step (and last) is to select a CNCJob made from \n"
-            "a solder paste dispensing geometry, and then view/save it's GCode."
+           _( "Fourth step (and last) is to select a CNCJob made from \n"
+            "a solder paste dispensing geometry, and then view/save it's GCode.")
         )
 
         grid4.addWidget(step4_lbl, 0, 0)
@@ -395,7 +395,7 @@ class SolderPaste(FlatCAMTool):
         self.flat_geometry = []
 
         # action to be added in the combobox context menu
-        self.combo_context_del_action = QtWidgets.QAction(QtGui.QIcon('share/trash16.png'), "Delete Object")
+        self.combo_context_del_action = QtWidgets.QAction(QtGui.QIcon('share/trash16.png'), _("Delete Object"))
 
         ## Signals
         self.combo_context_del_action.triggered.connect(self.on_delete_object)
@@ -457,9 +457,9 @@ class SolderPaste(FlatCAMTool):
 
         self.tools_table.setupContextMenu()
         self.tools_table.addContextMenu(
-            "Add", lambda: self.on_tool_add(dia=None, muted=None), icon=QtGui.QIcon("share/plus16.png"))
+            _("Add"), lambda: self.on_tool_add(dia=None, muted=None), icon=QtGui.QIcon("share/plus16.png"))
         self.tools_table.addContextMenu(
-            "Delete", lambda:
+            _("Delete"), lambda:
             self.on_tool_delete(rows_to_delete=None, all=None), icon=QtGui.QIcon("share/delete32.png"))
 
         try:
@@ -734,16 +734,16 @@ class SolderPaste(FlatCAMTool):
                 try:
                     tool_dia = float(self.addtool_entry.get_value().replace(',', '.'))
                 except ValueError:
-                    self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                         "use a number.")
+                    self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                         "use a number."))
                     return
             if tool_dia is None:
                 self.build_ui()
-                self.app.inform.emit("[WARNING_NOTCL] Please enter a tool diameter to add, in Float format.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Please enter a tool diameter to add, in Float format."))
                 return
 
         if tool_dia == 0:
-            self.app.inform.emit("[WARNING_NOTCL] Please enter a tool diameter with non-zero value, in Float format.")
+            self.app.inform.emit(_("[WARNING_NOTCL] Please enter a tool diameter with non-zero value, in Float format."))
             return
 
         # construct a list of all 'tooluid' in the self.tooltable_tools
@@ -767,12 +767,12 @@ class SolderPaste(FlatCAMTool):
 
         if float('%.4f' % tool_dia) in tool_dias:
             if muted is None:
-                self.app.inform.emit("[WARNING_NOTCL]Adding Nozzle tool cancelled. Tool already in Tool Table.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Adding Nozzle tool cancelled. Tool already in Tool Table."))
             self.tools_table.itemChanged.connect(self.on_tool_edit)
             return
         else:
             if muted is None:
-                self.app.inform.emit("[success] New Nozzle tool added to Tool Table.")
+                self.app.inform.emit(_("[success] New Nozzle tool added to Tool Table."))
             self.tooltable_tools.update({
                 int(self.tooluid): {
                     'tooldia': float('%.4f' % tool_dia),
@@ -805,8 +805,8 @@ class SolderPaste(FlatCAMTool):
                 try:
                     new_tool_dia = float(self.tools_table.item(row, 1).text().replace(',', '.'))
                 except ValueError:
-                    self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered, "
-                                         "use a number.")
+                    self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered, "
+                                         "use a number."))
                     return
 
             tooluid = int(self.tools_table.item(row, 2).text())
@@ -814,7 +814,7 @@ class SolderPaste(FlatCAMTool):
             # identify the tool that was edited and get it's tooluid
             if new_tool_dia not in tool_dias:
                 self.tooltable_tools[tooluid]['tooldia'] = new_tool_dia
-                self.app.inform.emit("[success] Nozzle tool from Tool Table was edited.")
+                self.app.inform.emit(_("[success] Nozzle tool from Tool Table was edited."))
                 self.build_ui()
                 return
             else:
@@ -825,7 +825,7 @@ class SolderPaste(FlatCAMTool):
                         break
                 restore_dia_item = self.tools_table.item(row, 1)
                 restore_dia_item.setText(str(old_tool_dia))
-                self.app.inform.emit("[WARNING_NOTCL] Edit cancelled. New diameter value is already in the Tool Table.")
+                self.app.inform.emit(_("[WARNING_NOTCL] Edit cancelled. New diameter value is already in the Tool Table."))
         self.build_ui()
 
     def on_tool_delete(self, rows_to_delete=None, all=None):
@@ -870,12 +870,12 @@ class SolderPaste(FlatCAMTool):
                     self.tooltable_tools.pop(t, None)
 
         except AttributeError:
-            self.app.inform.emit("[WARNING_NOTCL] Delete failed. Select a Nozzle tool to delete.")
+            self.app.inform.emit(_("[WARNING_NOTCL] Delete failed. Select a Nozzle tool to delete."))
             return
         except Exception as e:
             log.debug(str(e))
 
-        self.app.inform.emit("[success] Nozzle tool(s) deleted from Tool Table.")
+        self.app.inform.emit(_("[success] Nozzle tool(s) deleted from Tool Table."))
         self.build_ui()
 
     def on_rmb_combo(self, pos, combo):
@@ -930,7 +930,7 @@ class SolderPaste(FlatCAMTool):
         """
         name = self.obj_combo.currentText()
         if name == '':
-            self.app.inform.emit("[WARNING_NOTCL] No SolderPaste mask Gerber object loaded.")
+            self.app.inform.emit(_("[WARNING_NOTCL] No SolderPaste mask Gerber object loaded."))
             return
 
         obj = self.app.collection.get_by_name(name)
@@ -947,7 +947,7 @@ class SolderPaste(FlatCAMTool):
         :param work_object: the source Gerber object from which the geometry is created
         :return: a Geometry type object
         """
-        proc = self.app.proc_container.new("Creating Solder Paste dispensing geometry.")
+        proc = self.app.proc_container.new(_("Creating Solder Paste dispensing geometry."))
         obj = work_object
 
         # Sort tools in descending order
@@ -959,7 +959,7 @@ class SolderPaste(FlatCAMTool):
         sorted_tools.sort(reverse=True)
 
         if not sorted_tools:
-            self.app.inform.emit("[WARNING_NOTCL] No Nozzle tools in the tool table.")
+            self.app.inform.emit(_("[WARNING_NOTCL] No Nozzle tools in the tool table."))
             return 'fail'
 
         def flatten(geometry=None, reset=True, pathonly=False):
@@ -1085,17 +1085,17 @@ class SolderPaste(FlatCAMTool):
                         if not geo_obj.tools[tooluid_key]['solid_geometry']:
                             a += 1
                     if a == len(geo_obj.tools):
-                        self.app.inform.emit('[ERROR_NOTCL]Cancelled. Empty file, it has no geometry...')
+                        self.app.inform.emit(_('[ERROR_NOTCL] Cancelled. Empty file, it has no geometry...'))
                         return 'fail'
 
-                    app_obj.inform.emit("[success] Solder Paste geometry generated successfully...")
+                    app_obj.inform.emit(_("[success] Solder Paste geometry generated successfully..."))
                     return
 
             # if we still have geometry not processed at the end of the tools then we failed
             # some or all the pads are not covered with solder paste
             if work_geo:
-                app_obj.inform.emit("[WARNING_NOTCL] Some or all pads have no solder "
-                                    "due of inadequate nozzle diameters...")
+                app_obj.inform.emit(_("[WARNING_NOTCL] Some or all pads have no solder "
+                                    "due of inadequate nozzle diameters..."))
                 return 'fail'
 
         if use_thread:
@@ -1108,7 +1108,7 @@ class SolderPaste(FlatCAMTool):
                     return
                 proc.done()
 
-            self.app.inform.emit("Generating Solder Paste dispensing geometry...")
+            self.app.inform.emit(_("Generating Solder Paste dispensing geometry..."))
             # Promise object with the new name
             self.app.collection.promise(name)
 
@@ -1128,11 +1128,11 @@ class SolderPaste(FlatCAMTool):
         obj = self.app.collection.get_by_name(name)
 
         if name == '':
-            self.app.inform.emit("[WARNING_NOTCL]There is no Geometry object available.")
+            self.app.inform.emit(_("[WARNING_NOTCL] There is no Geometry object available."))
             return 'fail'
 
         if obj.special_group != 'solder_paste_tool':
-            self.app.inform.emit("[WARNING_NOTCL]This Geometry can't be processed. NOT a solder_paste_tool geometry.")
+            self.app.inform.emit(_("[WARNING_NOTCL] This Geometry can't be processed. NOT a solder_paste_tool geometry."))
             return 'fail'
 
         a = 0
@@ -1140,7 +1140,7 @@ class SolderPaste(FlatCAMTool):
             if obj.tools[tooluid_key]['solid_geometry'] is None:
                 a += 1
         if a == len(obj.tools):
-            self.app.inform.emit('[ERROR_NOTCL]Cancelled. Empty file, it has no geometry...')
+            self.app.inform.emit(_('[ERROR_NOTCL] Cancelled. Empty file, it has no geometry...'))
             return 'fail'
 
         # use the name of the first tool selected in self.geo_tools_table which has the diameter passed as tool_dia
@@ -1237,7 +1237,7 @@ class SolderPaste(FlatCAMTool):
             def job_thread(app_obj):
                 with self.app.proc_container.new("Generating CNC Code"):
                     if app_obj.new_object("cncjob", name, job_init) != 'fail':
-                        app_obj.inform.emit("[success]ToolSolderPaste CNCjob created: %s" % name)
+                        app_obj.inform.emit(_("[success] ToolSolderPaste CNCjob created: %s") % name)
                         app_obj.progress.emit(100)
 
             # Create a promise with the name
@@ -1269,12 +1269,12 @@ class SolderPaste(FlatCAMTool):
 
         try:
             if obj.special_group != 'solder_paste_tool':
-                self.app.inform.emit("[WARNING_NOTCL]This CNCJob object can't be processed. "
-                                     "NOT a solder_paste_tool CNCJob object.")
+                self.app.inform.emit(_("[WARNING_NOTCL] This CNCJob object can't be processed. "
+                                     "NOT a solder_paste_tool CNCJob object."))
                 return
         except AttributeError:
-            self.app.inform.emit("[WARNING_NOTCL]This CNCJob object can't be processed. "
-                                 "NOT a solder_paste_tool CNCJob object.")
+            self.app.inform.emit(_("[WARNING_NOTCL] This CNCJob object can't be processed. "
+                                 "NOT a solder_paste_tool CNCJob object."))
             return
 
         gcode = '(G-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s)\n' % \
@@ -1296,7 +1296,7 @@ class SolderPaste(FlatCAMTool):
         try:
             lines = StringIO(gcode)
         except:
-            self.app.inform.emit("[ERROR_NOTCL] No Gcode in the object...")
+            self.app.inform.emit(_("[ERROR_NOTCL] No Gcode in the object..."))
             return
 
         try:
@@ -1305,7 +1305,7 @@ class SolderPaste(FlatCAMTool):
                 self.app.ui.code_editor.append(proc_line)
         except Exception as e:
             log.debug('ToolSolderPaste.on_view_gcode() -->%s' % str(e))
-            self.app.inform.emit('[ERROR]ToolSolderPaste.on_view_gcode() -->%s' % str(e))
+            self.app.inform.emit(_('[ERROR] ToolSolderPaste.on_view_gcode() -->%s') % str(e))
             return
 
         self.app.ui.code_editor.moveCursor(QtGui.QTextCursor.Start)
@@ -1324,8 +1324,8 @@ class SolderPaste(FlatCAMTool):
         obj = self.app.collection.get_by_name(name)
 
         if obj.special_group != 'solder_paste_tool':
-            self.app.inform.emit("[WARNING_NOTCL]This CNCJob object can't be processed. "
-                                 "NOT a solder_paste_tool CNCJob object.")
+            self.app.inform.emit(_("[WARNING_NOTCL] This CNCJob object can't be processed. "
+                                 "NOT a solder_paste_tool CNCJob object."))
             return
 
         _filter_ = "G-Code Files (*.nc);;G-Code Files (*.txt);;G-Code Files (*.tap);;G-Code Files (*.cnc);;" \
@@ -1342,7 +1342,7 @@ class SolderPaste(FlatCAMTool):
             filename, _ = QtWidgets.QFileDialog.getSaveFileName(caption="Export Machine Code ...", filter=_filter_)
 
         if filename == '':
-            self.app.inform.emit("[WARNING_NOTCL]Export Machine Code cancelled ...")
+            self.app.inform.emit(_("[WARNING_NOTCL] Export Machine Code cancelled ..."))
             return
 
         gcode = '(G-CODE GENERATED BY FLATCAM v%s - www.flatcam.org - Version Date: %s)\n' % \
@@ -1368,11 +1368,11 @@ class SolderPaste(FlatCAMTool):
                     for line in lines:
                         f.write(line)
             except FileNotFoundError:
-                self.app.inform.emit("[WARNING_NOTCL] No such file or directory")
+                self.app.inform.emit(_("[WARNING_NOTCL] No such file or directory"))
                 return
 
         self.app.file_saved.emit("gcode", filename)
-        self.app.inform.emit("[success] Solder paste dispenser GCode file saved to: %s" % filename)
+        self.app.inform.emit(_("[success] Solder paste dispenser GCode file saved to: %s") % filename)
 
     def reset_fields(self):
         self.obj_combo.setRootModelIndex(self.app.collection.index(0, 0, QtCore.QModelIndex()))

flatcamTools/ToolTransform.py

@@ -7,12 +7,12 @@ from FlatCAMObj import *
 
 class ToolTransform(FlatCAMTool):
 
-    toolName = "Object Transform"
-    rotateName = "Rotate"
-    skewName = "Skew/Shear"
-    scaleName = "Scale"
-    flipName = "Mirror (Flip)"
-    offsetName = "Offset"
+    toolName = _("Object Transform")
+    rotateName = _("Rotate")
+    skewName = _("Skew/Shear")
+    scaleName = _("Scale")
+    flipName = _("Mirror (Flip)")
+    offsetName = _("Offset")
 
     def __init__(self, app):
         FlatCAMTool.__init__(self, app)
@@ -52,12 +52,12 @@ class ToolTransform(FlatCAMTool):
         self.transform_lay.addLayout(form_layout)
         form_child = QtWidgets.QHBoxLayout()
 
-        self.rotate_label = QtWidgets.QLabel("Angle:")
+        self.rotate_label = QtWidgets.QLabel(_("Angle:"))
         self.rotate_label.setToolTip(
-            "Angle for Rotation action, in degrees.\n"
+            _("Angle for Rotation action, in degrees.\n"
             "Float number between -360 and 359.\n"
             "Positive numbers for CW motion.\n"
-            "Negative numbers for CCW motion."
+            "Negative numbers for CCW motion.")
         )
         self.rotate_label.setFixedWidth(50)
 
@@ -66,11 +66,11 @@ class ToolTransform(FlatCAMTool):
         self.rotate_entry.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
 
         self.rotate_button = FCButton()
-        self.rotate_button.set_value("Rotate")
+        self.rotate_button.set_value(_("Rotate"))
         self.rotate_button.setToolTip(
-            "Rotate the selected object(s).\n"
+            _("Rotate the selected object(s).\n"
             "The point of reference is the middle of\n"
-            "the bounding box for all selected objects."
+            "the bounding box for all selected objects.")
         )
         self.rotate_button.setFixedWidth(60)
 
@@ -91,10 +91,10 @@ class ToolTransform(FlatCAMTool):
         form1_child_1 = QtWidgets.QHBoxLayout()
         form1_child_2 = QtWidgets.QHBoxLayout()
 
-        self.skewx_label = QtWidgets.QLabel("Angle X:")
+        self.skewx_label = QtWidgets.QLabel(_("Angle X:"))
         self.skewx_label.setToolTip(
-            "Angle for Skew action, in degrees.\n"
-            "Float number between -360 and 359."
+            _("Angle for Skew action, in degrees.\n"
+            "Float number between -360 and 359.")
         )
         self.skewx_label.setFixedWidth(50)
         self.skewx_entry = FCEntry()
@@ -102,17 +102,17 @@ class ToolTransform(FlatCAMTool):
         # self.skewx_entry.setFixedWidth(60)
 
         self.skewx_button = FCButton()
-        self.skewx_button.set_value("Skew X")
+        self.skewx_button.set_value(_("Skew X"))
         self.skewx_button.setToolTip(
-            "Skew/shear the selected object(s).\n"
+            _("Skew/shear the selected object(s).\n"
             "The point of reference is the middle of\n"
-            "the bounding box for all selected objects.")
+            "the bounding box for all selected objects."))
         self.skewx_button.setFixedWidth(60)
 
-        self.skewy_label = QtWidgets.QLabel("Angle Y:")
+        self.skewy_label = QtWidgets.QLabel(_("Angle Y:"))
         self.skewy_label.setToolTip(
-            "Angle for Skew action, in degrees.\n"
-            "Float number between -360 and 359."
+            _("Angle for Skew action, in degrees.\n"
+            "Float number between -360 and 359.")
         )
         self.skewy_label.setFixedWidth(50)
         self.skewy_entry = FCEntry()
@@ -120,11 +120,11 @@ class ToolTransform(FlatCAMTool):
         # self.skewy_entry.setFixedWidth(60)
 
         self.skewy_button = FCButton()
-        self.skewy_button.set_value("Skew Y")
+        self.skewy_button.set_value(_("Skew Y"))
         self.skewy_button.setToolTip(
-            "Skew/shear the selected object(s).\n"
+            _("Skew/shear the selected object(s).\n"
             "The point of reference is the middle of\n"
-            "the bounding box for all selected objects.")
+            "the bounding box for all selected objects."))
         self.skewy_button.setFixedWidth(60)
 
         form1_child_1.addWidget(self.skewx_entry)
@@ -148,9 +148,9 @@ class ToolTransform(FlatCAMTool):
         form2_child_1 = QtWidgets.QHBoxLayout()
         form2_child_2 = QtWidgets.QHBoxLayout()
 
-        self.scalex_label = QtWidgets.QLabel("Factor X:")
+        self.scalex_label = QtWidgets.QLabel(_("Factor X:"))
         self.scalex_label.setToolTip(
-            "Factor for Scale action over X axis."
+            _("Factor for Scale action over X axis.")
         )
         self.scalex_label.setFixedWidth(50)
         self.scalex_entry = FCEntry()
@@ -158,16 +158,16 @@ class ToolTransform(FlatCAMTool):
         # self.scalex_entry.setFixedWidth(60)
 
         self.scalex_button = FCButton()
-        self.scalex_button.set_value("Scale X")
+        self.scalex_button.set_value(_("Scale X"))
         self.scalex_button.setToolTip(
-            "Scale the selected object(s).\n"
+            _("Scale the selected object(s).\n"
             "The point of reference depends on \n"
-            "the Scale reference checkbox state.")
+            "the Scale reference checkbox state."))
         self.scalex_button.setFixedWidth(60)
 
-        self.scaley_label = QtWidgets.QLabel("Factor Y:")
+        self.scaley_label = QtWidgets.QLabel(_("Factor Y:"))
         self.scaley_label.setToolTip(
-            "Factor for Scale action over Y axis."
+            _("Factor for Scale action over Y axis.")
         )
         self.scaley_label.setFixedWidth(50)
         self.scaley_entry = FCEntry()
@@ -175,29 +175,29 @@ class ToolTransform(FlatCAMTool):
         # self.scaley_entry.setFixedWidth(60)
 
         self.scaley_button = FCButton()
-        self.scaley_button.set_value("Scale Y")
+        self.scaley_button.set_value(_("Scale Y"))
         self.scaley_button.setToolTip(
-            "Scale the selected object(s).\n"
+            _("Scale the selected object(s).\n"
             "The point of reference depends on \n"
-            "the Scale reference checkbox state.")
+            "the Scale reference checkbox state."))
         self.scaley_button.setFixedWidth(60)
 
         self.scale_link_cb = FCCheckBox()
         self.scale_link_cb.set_value(True)
-        self.scale_link_cb.setText("Link")
+        self.scale_link_cb.setText(_("Link"))
         self.scale_link_cb.setToolTip(
-            "Scale the selected object(s)\n"
-            "using the Scale Factor X for both axis.")
+            _("Scale the selected object(s)\n"
+            "using the Scale Factor X for both axis."))
         self.scale_link_cb.setFixedWidth(50)
 
         self.scale_zero_ref_cb = FCCheckBox()
         self.scale_zero_ref_cb.set_value(True)
-        self.scale_zero_ref_cb.setText("Scale Reference")
+        self.scale_zero_ref_cb.setText(_("Scale Reference"))
         self.scale_zero_ref_cb.setToolTip(
-            "Scale the selected object(s)\n"
+            _("Scale the selected object(s)\n"
             "using the origin reference when checked,\n"
             "and the center of the biggest bounding box\n"
-            "of the selected objects when unchecked.")
+            "of the selected objects when unchecked."))
 
         form2_child_1.addWidget(self.scalex_entry)
         form2_child_1.addWidget(self.scalex_button)
@@ -222,9 +222,9 @@ class ToolTransform(FlatCAMTool):
         form3_child_1 = QtWidgets.QHBoxLayout()
         form3_child_2 = QtWidgets.QHBoxLayout()
 
-        self.offx_label = QtWidgets.QLabel("Value X:")
+        self.offx_label = QtWidgets.QLabel(_("Value X:"))
         self.offx_label.setToolTip(
-            "Value for Offset action on X axis."
+            _("Value for Offset action on X axis.")
         )
         self.offx_label.setFixedWidth(50)
         self.offx_entry = FCEntry()
@@ -232,16 +232,16 @@ class ToolTransform(FlatCAMTool):
         # self.offx_entry.setFixedWidth(60)
 
         self.offx_button = FCButton()
-        self.offx_button.set_value("Offset X")
+        self.offx_button.set_value(_("Offset X"))
         self.offx_button.setToolTip(
-            "Offset the selected object(s).\n"
+            _("Offset the selected object(s).\n"
             "The point of reference is the middle of\n"
-            "the bounding box for all selected objects.\n")
+            "the bounding box for all selected objects.\n"))
         self.offx_button.setFixedWidth(60)
 
-        self.offy_label = QtWidgets.QLabel("Value Y:")
+        self.offy_label = QtWidgets.QLabel(_("Value Y:"))
         self.offy_label.setToolTip(
-            "Value for Offset action on Y axis."
+            _("Value for Offset action on Y axis.")
         )
         self.offy_label.setFixedWidth(50)
         self.offy_entry = FCEntry()
@@ -249,11 +249,11 @@ class ToolTransform(FlatCAMTool):
         # self.offy_entry.setFixedWidth(60)
 
         self.offy_button = FCButton()
-        self.offy_button.set_value("Offset Y")
+        self.offy_button.set_value(_("Offset Y"))
         self.offy_button.setToolTip(
-            "Offset the selected object(s).\n"
+            _("Offset the selected object(s).\n"
             "The point of reference is the middle of\n"
-            "the bounding box for all selected objects.\n")
+            "the bounding box for all selected objects.\n"))
         self.offy_button.setFixedWidth(60)
 
         form3_child_1.addWidget(self.offx_entry)
@@ -279,26 +279,26 @@ class ToolTransform(FlatCAMTool):
         form4_child_1 = QtWidgets.QHBoxLayout()
 
         self.flipx_button = FCButton()
-        self.flipx_button.set_value("Flip on X")
+        self.flipx_button.set_value(_("Flip on X"))
         self.flipx_button.setToolTip(
-            "Flip the selected object(s) over the X axis.\n"
-            "Does not create a new object.\n "
+            _("Flip the selected object(s) over the X axis.\n"
+            "Does not create a new object.\n ")
         )
         self.flipx_button.setFixedWidth(60)
 
         self.flipy_button = FCButton()
-        self.flipy_button.set_value("Flip on Y")
+        self.flipy_button.set_value(_("Flip on Y"))
         self.flipy_button.setToolTip(
-            "Flip the selected object(s) over the X axis.\n"
-            "Does not create a new object.\n "
+            _("Flip the selected object(s) over the X axis.\n"
+            "Does not create a new object.\n ")
         )
         self.flipy_button.setFixedWidth(60)
 
         self.flip_ref_cb = FCCheckBox()
         self.flip_ref_cb.set_value(True)
-        self.flip_ref_cb.setText("Ref Pt")
+        self.flip_ref_cb.setText(_("Ref Pt"))
         self.flip_ref_cb.setToolTip(
-            "Flip the selected object(s)\n"
+            _("Flip the selected object(s)\n"
             "around the point in Point Entry Field.\n"
             "\n"
             "The point coordinates can be captured by\n"
@@ -306,14 +306,14 @@ class ToolTransform(FlatCAMTool):
             "SHIFT key. \n"
             "Then click Add button to insert coordinates.\n"
             "Or enter the coords in format (x, y) in the\n"
-            "Point Entry field and click Flip on X(Y)")
+            "Point Entry field and click Flip on X(Y)"))
         self.flip_ref_cb.setFixedWidth(50)
 
-        self.flip_ref_label = QtWidgets.QLabel("Point:")
+        self.flip_ref_label = QtWidgets.QLabel(_("Point:"))
         self.flip_ref_label.setToolTip(
-            "Coordinates in format (x, y) used as reference for mirroring.\n"
+            _("Coordinates in format (x, y) used as reference for mirroring.\n"
             "The 'x' in (x, y) will be used when using Flip on X and\n"
-            "the 'y' in (x, y) will be used when using Flip on Y and"
+            "the 'y' in (x, y) will be used when using Flip on Y and")
         )
         self.flip_ref_label.setFixedWidth(50)
         self.flip_ref_entry = EvalEntry2("(0, 0)")
@@ -321,11 +321,11 @@ class ToolTransform(FlatCAMTool):
         # self.flip_ref_entry.setFixedWidth(60)
 
         self.flip_ref_button = FCButton()
-        self.flip_ref_button.set_value("Add")
+        self.flip_ref_button.set_value(_("Add"))
         self.flip_ref_button.setToolTip(
-            "The point coordinates can be captured by\n"
+            _("The point coordinates can be captured by\n"
             "left click on canvas together with pressing\n"
-            "SHIFT key. Then click Add button to insert.")
+            "SHIFT key. Then click Add button to insert."))
         self.flip_ref_button.setFixedWidth(60)
 
         form4_child_hlay.addStretch()
@@ -379,7 +379,7 @@ class ToolTransform(FlatCAMTool):
         FlatCAMTool.run(self)
         self.set_tool_ui()
 
-        self.app.ui.notebook.setTabText(2, "Transform Tool")
+        self.app.ui.notebook.setTabText(2, _("Transform Tool"))
 
     def install(self, icon=None, separator=None, **kwargs):
         FlatCAMTool.install(self, icon, separator, shortcut='ALT+T', **kwargs)
@@ -449,8 +449,8 @@ class ToolTransform(FlatCAMTool):
             try:
                 value = float(self.rotate_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered for Rotate, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered for Rotate, "
+                                     "use a number."))
                 return
         self.app.worker_task.emit({'fcn': self.on_rotate_action,
                                        'params': [value]})
@@ -483,8 +483,8 @@ class ToolTransform(FlatCAMTool):
             try:
                 value = float(self.skewx_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered for Skew X, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered for Skew X, "
+                                     "use a number."))
                 return
 
         # self.on_skew("X", value)
@@ -501,8 +501,8 @@ class ToolTransform(FlatCAMTool):
             try:
                 value = float(self.skewy_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered for Skew Y, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered for Skew Y, "
+                                     "use a number."))
                 return
 
         # self.on_skew("Y", value)
@@ -519,8 +519,8 @@ class ToolTransform(FlatCAMTool):
             try:
                 xvalue = float(self.scalex_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered for Scale X, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered for Scale X, "
+                                     "use a number."))
                 return
 
         # scaling to zero has no sense so we remove it, because scaling with 1 does nothing
@@ -553,8 +553,8 @@ class ToolTransform(FlatCAMTool):
             try:
                 yvalue = float(self.scaley_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered for Scale Y, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered for Scale Y, "
+                                     "use a number."))
                 return
 
         # scaling to zero has no sense so we remove it, because scaling with 1 does nothing
@@ -582,8 +582,8 @@ class ToolTransform(FlatCAMTool):
             try:
                 value = float(self.offx_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered for Offset X, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered for Offset X, "
+                                     "use a number."))
                 return
 
         # self.on_offset("X", value)
@@ -600,8 +600,8 @@ class ToolTransform(FlatCAMTool):
             try:
                 value = float(self.offy_entry.get_value().replace(',', '.'))
             except ValueError:
-                self.app.inform.emit("[ERROR_NOTCL]Wrong value format entered for Offset Y, "
-                                     "use a number.")
+                self.app.inform.emit(_("[ERROR_NOTCL]Wrong value format entered for Offset Y, "
+                                     "use a number."))
                 return
 
         # self.on_offset("Y", value)
@@ -618,10 +618,10 @@ class ToolTransform(FlatCAMTool):
         ymaxlist = []
 
         if not obj_list:
-            self.app.inform.emit("[WARNING_NOTCL] No object selected. Please Select an object to rotate!")
+            self.app.inform.emit(_("[WARNING_NOTCL] No object selected. Please Select an object to rotate!"))
             return
         else:
-            with self.app.proc_container.new("Appying Rotate"):
+            with self.app.proc_container.new(_("Appying Rotate")):
                 try:
                     # first get a bounding box to fit all
                     for obj in obj_list:
@@ -646,7 +646,7 @@ class ToolTransform(FlatCAMTool):
                         px = 0.5 * (xminimal + xmaximal)
                         py = 0.5 * (yminimal + ymaximal)
                         if isinstance(sel_obj, FlatCAMCNCjob):
-                            self.app.inform.emit("CNCJob objects can't be rotated.")
+                            self.app.inform.emit(_("CNCJob objects can't be rotated."))
                         else:
                             sel_obj.rotate(-num, point=(px, py))
                             sel_obj.plot()
@@ -655,11 +655,11 @@ class ToolTransform(FlatCAMTool):
                         # add information to the object that it was changed and how much
                         sel_obj.options['rotate'] = num
 
-                    self.app.inform.emit('[success]Rotate done ...')
+                    self.app.inform.emit(_('[success]Rotate done ...'))
                     self.app.progress.emit(100)
 
                 except Exception as e:
-                    self.app.inform.emit("[ERROR_NOTCL] Due of %s, rotation movement was not executed." % str(e))
+                    self.app.inform.emit(_("[ERROR_NOTCL] Due of %s, rotation movement was not executed.") % str(e))
                     return
 
     def on_flip(self, axis):
@@ -670,10 +670,10 @@ class ToolTransform(FlatCAMTool):
         ymaxlist = []
 
         if not obj_list:
-            self.app.inform.emit("[WARNING_NOTCL] No object selected. Please Select an object to flip!")
+            self.app.inform.emit(_("[WARNING_NOTCL] No object selected. Please Select an object to flip!"))
             return
         else:
-            with self.app.proc_container.new("Applying Flip"):
+            with self.app.proc_container.new(_("Applying Flip")):
                 try:
                     # get mirroring coords from the point entry
                     if self.flip_ref_cb.isChecked():
@@ -705,7 +705,7 @@ class ToolTransform(FlatCAMTool):
                     # execute mirroring
                     for obj in obj_list:
                         if isinstance(obj, FlatCAMCNCjob):
-                            self.app.inform.emit("CNCJob objects can't be mirrored/flipped.")
+                            self.app.inform.emit(_("CNCJob objects can't be mirrored/flipped."))
                         else:
                             if axis is 'X':
                                 obj.mirror('X', (px, py))
@@ -716,7 +716,7 @@ class ToolTransform(FlatCAMTool):
                                 else:
                                     obj.options['mirror_y'] = True
                                 obj.plot()
-                                self.app.inform.emit('[success]Flip on the Y axis done ...')
+                                self.app.inform.emit(_('[success]Flip on the Y axis done ...'))
                             elif axis is 'Y':
                                 obj.mirror('Y', (px, py))
                                 # add information to the object that it was changed and how much
@@ -726,12 +726,12 @@ class ToolTransform(FlatCAMTool):
                                 else:
                                     obj.options['mirror_x'] = True
                                 obj.plot()
-                                self.app.inform.emit('[success]Flip on the X axis done ...')
+                                self.app.inform.emit(_('[success]Flip on the X axis done ...'))
                             self.app.object_changed.emit(obj)
                     self.app.progress.emit(100)
 
                 except Exception as e:
-                    self.app.inform.emit("[ERROR_NOTCL] Due of %s, Flip action was not executed." % str(e))
+                    self.app.inform.emit(_("[ERROR_NOTCL] Due of %s, Flip action was not executed.") % str(e))
                     return
 
     def on_skew(self, axis, num):
@@ -740,10 +740,10 @@ class ToolTransform(FlatCAMTool):
         yminlist = []
 
         if not obj_list:
-            self.app.inform.emit("[WARNING_NOTCL] No object selected. Please Select an object to shear/skew!")
+            self.app.inform.emit(_("[WARNING_NOTCL] No object selected. Please Select an object to shear/skew!"))
             return
         else:
-            with self.app.proc_container.new("Applying Skew"):
+            with self.app.proc_container.new(_("Applying Skew")):
                 try:
                     # first get a bounding box to fit all
                     for obj in obj_list:
@@ -762,7 +762,7 @@ class ToolTransform(FlatCAMTool):
 
                     for obj in obj_list:
                         if isinstance(obj, FlatCAMCNCjob):
-                            self.app.inform.emit("CNCJob objects can't be skewed.")
+                            self.app.inform.emit(_("CNCJob objects can't be skewed."))
                         else:
                             if axis is 'X':
                                 obj.skew(num, 0, point=(xminimal, yminimal))
@@ -774,11 +774,11 @@ class ToolTransform(FlatCAMTool):
                                 obj.options['skew_y'] = num
                             obj.plot()
                             self.app.object_changed.emit(obj)
-                    self.app.inform.emit('[success]Skew on the %s axis done ...' % str(axis))
+                    self.app.inform.emit(_('[success]Skew on the %s axis done ...') % str(axis))
                     self.app.progress.emit(100)
 
                 except Exception as e:
-                    self.app.inform.emit("[ERROR_NOTCL] Due of %s, Skew action was not executed." % str(e))
+                    self.app.inform.emit(_("[ERROR_NOTCL] Due of %s, Skew action was not executed.") % str(e))
                     return
 
     def on_scale(self, axis, xfactor, yfactor, point=None):
@@ -789,10 +789,10 @@ class ToolTransform(FlatCAMTool):
         ymaxlist = []
 
         if not obj_list:
-            self.app.inform.emit("[WARNING_NOTCL] No object selected. Please Select an object to scale!")
+            self.app.inform.emit(_("[WARNING_NOTCL] No object selected. Please Select an object to scale!"))
             return
         else:
-            with self.app.proc_container.new("Applying Scale"):
+            with self.app.proc_container.new(_("Applying Scale")):
                 try:
                     # first get a bounding box to fit all
                     for obj in obj_list:
@@ -822,7 +822,7 @@ class ToolTransform(FlatCAMTool):
 
                     for obj in obj_list:
                         if isinstance(obj, FlatCAMCNCjob):
-                            self.app.inform.emit("CNCJob objects can't be scaled.")
+                            self.app.inform.emit(_("CNCJob objects can't be scaled."))
                         else:
                             obj.scale(xfactor, yfactor, point=(px, py))
                             # add information to the object that it was changed and how much
@@ -830,10 +830,10 @@ class ToolTransform(FlatCAMTool):
                             obj.options['scale_y'] = yfactor
                             obj.plot()
                             self.app.object_changed.emit(obj)
-                    self.app.inform.emit('[success]Scale on the %s axis done ...' % str(axis))
+                    self.app.inform.emit(_('[success] Scale on the %s axis done ...') % str(axis))
                     self.app.progress.emit(100)
                 except Exception as e:
-                    self.app.inform.emit("[ERROR_NOTCL] Due of %s, Scale action was not executed." % str(e))
+                    self.app.inform.emit(_("[ERROR_NOTCL] Due of %s, Scale action was not executed.") % str(e))
                     return
 
     def on_offset(self, axis, num):
@@ -842,10 +842,10 @@ class ToolTransform(FlatCAMTool):
         yminlist = []
 
         if not obj_list:
-            self.app.inform.emit("[WARNING_NOTCL] No object selected. Please Select an object to offset!")
+            self.app.inform.emit(_("[WARNING_NOTCL] No object selected. Please Select an object to offset!"))
             return
         else:
-            with self.app.proc_container.new("Applying Offset"):
+            with self.app.proc_container.new(_("Applying Offset")):
                 try:
                     # first get a bounding box to fit all
                     for obj in obj_list:
@@ -863,7 +863,7 @@ class ToolTransform(FlatCAMTool):
 
                     for obj in obj_list:
                         if isinstance(obj, FlatCAMCNCjob):
-                            self.app.inform.emit("CNCJob objects can't be offseted.")
+                            self.app.inform.emit(_("CNCJob objects can't be offseted."))
                         else:
                             if axis is 'X':
                                 obj.offset((num, 0))
@@ -875,11 +875,11 @@ class ToolTransform(FlatCAMTool):
                                 obj.options['offset_y'] = num
                             obj.plot()
                             self.app.object_changed.emit(obj)
-                    self.app.inform.emit('[success]Offset on the %s axis done ...' % str(axis))
+                    self.app.inform.emit(_('[success]Offset on the %s axis done ...') % str(axis))
                     self.app.progress.emit(100)
 
                 except Exception as e:
-                    self.app.inform.emit("[ERROR_NOTCL] Due of %s, Offset action was not executed." % str(e))
+                    self.app.inform.emit(_("[ERROR_NOTCL] Due of %s, Offset action was not executed.") % str(e))
                     return
 
-# end of file
+# end of file