path: root/src/emc/usr_intf/gmoccapy/gmoccapy.py

#!/usr/bin/python
# -*- coding:UTF-8 -*-
"""
    A try of a new GUI for LinuxCNC based on gladevcp and Python
    Based on the design of moccagui from Tom
    and with a lot of code from gscreen from Chris Morley
    and with the help from Michael Haberler
    and Chris Morley and some more

    Copyright 2012 Norbert Schechner
    nieson@web.de

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

"""
import traceback            # needed to launch traceback errors
import hal                  # base hal class to react to hal signals
import hal_glib             # needed to make our own hal pins
import gtk                  # base for pygtk widgets and constants
import sys                  # handle system calls
import os                   # needed to get the paths and directorys
import pango                # needed for font settings and changing
import gladevcp.makepins    # needed for the dialog"s calulator widget
import atexit               # needed to register childs to be closed on closing the GUI
import subprocess           # to launch onboard and other proceses
import vte                  # To get the embedded terminal
import tempfile             # needed only if the user click new in edit mode to open a new empty file
import linuxcnc             # to get our own error sytsem
import gobject              # needed to add the timer for periodic
import locale               # for setting the language of the GUI
import gettext              # to extract the strings to be translated

from gladevcp.gladebuilder import GladeBuilder

from time import strftime           # needed to add a time stamp with alarm entrys
from time import localtime          # # needed to add a time stamp with alarm entrys

# Throws up a dialog with debug info when an error is encountered
def excepthook(exc_type, exc_obj, exc_tb):
    try:
        w = app.widgets.window1
    except KeyboardInterrupt:
        sys.exit(0)
    except NameError:
        w = None
    lines = traceback.format_exception(exc_type, exc_obj, exc_tb)
    m = gtk.MessageDialog(w,
                gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
                gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
                ("Found an error!\nThe following information may be useful in troubleshooting:\n\n")
                + "".join(lines))
    m.show()
    m.run()
    m.destroy()
sys.excepthook = excepthook

debug = False

if debug:
    pydevdir = '/home/emcmesa/Aptana_Studio_3/plugins/org.python.pydev_2.7.0.2013032300/pysrc'

    if os.path.isdir(pydevdir): # and  'emctask' in sys.builtin_module_names:
        sys.path.append(pydevdir)
        sys.path.insert(0, pydevdir)
        try:
            import pydevd
            print("pydevd imported, connecting to Eclipse debug server...")
            pydevd.settrace()
        except:
            print("no pydevd module found")
            pass

# constants
#          # gmoccapy  #"
_RELEASE = "  1.1.5.3"
_INCH = 0                           # imperial units are active
_MM = 1                             # metric units are active
_TEMPDIR = tempfile.gettempdir()    # Now we know where the tempdir is, usualy /tmp

# set up paths to files
BASE = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), ".."))
LIBDIR = os.path.join(BASE, "lib", "python")
sys.path.insert(0, LIBDIR)

# as now we know the libdir path we can import our own modules
from gmoccapy import widgets        # a class to handle the widgets
from gmoccapy import player         # a class to handle sounds
from gmoccapy import notification   # this is the module we use for our error handling
from gmoccapy import preferences    # this handles the preferences
from gmoccapy import getiniinfo     # this handles the INI File reading so checking is done in that module
from gmoccapy import dialogs        # this takes the code of all our dialogs

# set up paths to files, part two
CONFIGPATH = os.environ['CONFIG_DIR']
DATADIR = os.path.join(BASE, "share", "gmoccapy")
IMAGEDIR = os.path.join(DATADIR, "images")
XMLNAME = os.path.join(DATADIR, "gmoccapy.glade")
THEMEDIR = "/usr/share/themes"
LOCALEDIR = os.path.join(BASE, "share", "locale")

# path to TCL for external programs eg. halshow
TCLPATH = os.environ['LINUXCNC_TCL_DIR']

# the ICONS should must be in share/gmoccapy/images
ALERT_ICON = os.path.join(IMAGEDIR, "applet-critical.png")
INFO_ICON = os.path.join(IMAGEDIR, "std_info.gif")

# this is for hiding the pointer when using a touch screen
pixmap = gtk.gdk.Pixmap(None, 1, 1, 1)
color = gtk.gdk.Color()
INVISABLE = gtk.gdk.Cursor(pixmap, pixmap, color, color, 0, 0)

class gmoccapy(object):

    def __init__(self):

        # prepare for translation / internationalisation
        locale.setlocale(locale.LC_ALL, '')
        locale.bindtextdomain("gmoccapy", LOCALEDIR)
        gettext.install("gmoccapy", localedir = LOCALEDIR, unicode = True)
        gettext.bindtextdomain("gmoccapy", LOCALEDIR)

        # needed components to comunicate with hal and linuxcnc
        self.halcomp = hal.component("gmoccapy")
        self.command = linuxcnc.command()
        self.stat = linuxcnc.stat()
        self.error_channel = linuxcnc.error_channel()
        # initial poll, so all is up to date
        self.stat.poll()
        self.error_channel.poll()

        self.builder = gtk.Builder()
        # translation of the glade file will be done with
        self.builder.set_translation_domain("gmoccapy")
        self.builder.add_from_file(XMLNAME)
        self.builder.connect_signals(self)

        self.widgets = widgets.Widgets(self.builder)

        self.initialized = False  # will be set True after the window has been shown and all
                                  # basic settings has been finished, so we avoid some actions
                                  # because we cause click or toggle events when initializing
                                  # widget states.

        self.start_line = 0       # needed for start from line
        self.stepping = False     # used to sensitize widgets when using step by step

        self.active_gcodes = []   # this are the formated G code values
        self.active_mcodes = []   # this are the formated M code values
        self.gcodes = []          # this are the unformated G code values to check if an update is requiered
        self.mcodes = []          # this are the unformated M code values to check if an update is requiered

        self.distance = 0               # This global will hold the jog distance
        self.tool_change = False        # this is needed to get back to manual mode after a tool change
        self.macrobuttons = []          # The list of all macrios defined in the INI file
        self.log = False                # decide if the actions should be loged
        self.fo_counts = 0              # need to calculate diference in counts to change the feed override slider
        self.so_counts = 0              # need to calculate diference in counts to change the spindle override slider
        self.jv_counts = 0              # need to calculate diference in counts to change the jog_vel slider
        self.mv_counts = 0              # need to calculate diference in counts to change the max_speed slider
        self.incr_rbt_list = []         # we use this list to add hal pin to the button later
        self.jog_increments = []        # This holds the increment values
        self.unlock = False             # this value will be set using the hal pin unlock settings
                                        # needed to display the labels
        self.system_list = ("0", "G54", "G55", "G56", "G57", "G58", "G59", "G59.1", "G59.2", "G59.3")
        self.dro_size = 28              # The size of the DRO, user may want them bigger on bigger screen
        self.axisnumber_four = ""       # we use this to get the number of the 4-th axis
        self.axisletter_four = None     # we use this to get the letter of the 4-th axis
        self.hide_axis_4 = False        # will hold if the 4'th axis should be hidden

        self.notification = notification.Notification() # Our own message system
        self.notification.connect("message_deleted", self._on_message_deleted)
        self.last_key_event = None, 0   # needed to avoid the auto repeat function of the keyboard
        self.all_homed = False          # will hold True if all axis are homed
        self.faktor = 1.0               # needed to calculate velocitys
        # the default theme = System Theme we store here to be able to go back to that one later
        self.default_theme = gtk.settings_get_default().get_property("gtk-theme-name")


        # the sounds to play if an error or message rises
        self.alert_sound = "/usr/share/sounds/ubuntu/stereo/bell.ogg"
        self.error_sound = "/usr/share/sounds/ubuntu/stereo/dialog-question.ogg"

        # Our own clas to get information from ini the file we use this way, to be sure
        # to get a valid result, as the checks are done in that module
        self.get_ini_info = getiniinfo.GetIniInfo()

        self.prefs = preferences.preferences(self.get_ini_info.get_preference_file_path())

        self._get_axis_list()
        self._init_axis_four()
        self._init_jog_increments()

        self._init_hal_pins()

        # set the title of the window, to show the release
        self.widgets.window1.set_title("gmoccapy for linuxcnc %s" % _RELEASE)
        self.widgets.lbl_version.set_label("<b>gmoccapy\n%s</b>" % _RELEASE)

        panel = gladevcp.makepins.GladePanel(self.halcomp, XMLNAME , self.builder, None)

        self.halcomp.ready()

        # this are settings to be done before window show
        self._init_preferences()

        # finaly show the window
        self.widgets.window1.show()

        self._check_screen2()
        self._init_dynamic_tabs()
        self._init_tooleditor()
        self._init_embeded_terminal()
        self._init_themes()
        self._init_audio()
        self._init_gremlin()
        self._init_hide_cursor()
        self._init_keyboard()
        self._init_offsetpage()
        self._init_keybindings()
        self._init_IconFileSelection()

        # now we initialize the file to load widget
        self._init_file_to_load()

        self._show_offset_tab(False)
        self._show_tooledit_tab(False)
        self._show_iconview_tab(False)

        # check if the user want a Logo
        if self.prefs.getpref("logo", False, bool):
            logofile = self.prefs.getpref("logofile", None, str)
            if logofile:
                self.widgets.img_logo.set_from_file(logofile)
                self.widgets.img_logo.show()
                self.widgets.hbox_jog.hide()
                self.widgets.hbox_jog_vel.hide()

        # the velocity settings
        self.min_spindle_rev = self.prefs.getpref("spindle_bar_min", 0.0, float)
        self.max_spindle_rev = self.prefs.getpref("spindle_bar_max", 6000.0, float)
        self.widgets.adj_spindle_bar_min.set_value(self.min_spindle_rev)
        self.widgets.adj_spindle_bar_max.set_value(self.max_spindle_rev)
        self.widgets.spindle_feedback_bar.set_property("min", float(self.min_spindle_rev))
        self.widgets.spindle_feedback_bar.set_property("max", float(self.max_spindle_rev))

        # Window position and size
        self.widgets.adj_x_pos.set_value(self.prefs.getpref("x_pos", 10, float))
        self.widgets.adj_y_pos.set_value(self.prefs.getpref("y_pos", 25, float))
        self.widgets.adj_width.set_value(self.prefs.getpref("width", 979, float))
        self.widgets.adj_height.set_value(self.prefs.getpref("height", 750, float))

        # Popup Messages position and size
        self.widgets.adj_x_pos_popup.set_value(self.prefs.getpref("x_pos_popup", 15, float))
        self.widgets.adj_y_pos_popup.set_value(self.prefs.getpref("y_pos_popup", 55, float))
        self.widgets.adj_width_popup.set_value(self.prefs.getpref("width_popup", 250, float))
        self.widgets.adj_max_messages.set_value(self.prefs.getpref("max_messages", 10, float))
        self.widgets.fontbutton_popup.set_font_name(self.prefs.getpref("message_font", "sans 10", str))
        self.widgets.chk_use_frames.set_active(self.prefs.getpref("use_frames", True, bool))

# Only used if the DRO buttons will remain in gmoccapy
        self.widgets.chk_show_dro_btn.set_active(self.prefs.getpref("show_dro_btn", False, bool))
        self.widgets.chk_auto_units.set_active(self.prefs.getpref("use_auto_units", True, bool))
        self.on_chk_show_dro_btn_toggled(None)
        self.on_chk_auto_units_toggled(None)
        if self.widgets.Combi_DRO_x.machine_units == 0:
            self.widgets.tbtn_units.set_active(True)

        self.widgets.tbtn_rel.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_dtg.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_units.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
# end of the button usage

        # this sets the background colors of several buttons
        # the colors are different for the states of the button
        self.widgets.tbtn_on.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_estop.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FF0000"))
        self.widgets.tbtn_estop.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#00FF00"))
        self.widgets.rbt_manual.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.rbt_mdi.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.rbt_auto.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_setup.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.rbt_forward.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#00FF00"))
        self.widgets.rbt_reverse.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#00FF00"))
        self.widgets.rbt_stop.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.rbt_view_p.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.rbt_view_x.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.rbt_view_y.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.rbt_view_y2.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.rbt_view_z.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_flood.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#00FF00"))
        self.widgets.tbtn_fullsize_preview.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_fullsize_preview1.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_log_actions.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_mist.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#00FF00"))
        self.widgets.tbtn_optional_blocks.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_optional_stops.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_user_tabs.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_view_dimension.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_view_tool_path.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))
        self.widgets.tbtn_edit_offsets.modify_bg(gtk.STATE_ACTIVE, gtk.gdk.color_parse("#FFFF00"))

        # This is needed only because we connect all the horizontal button
        # to hal pins, so the user can conect them to hardware buttons
        self.h_tabs = []
        tab_main = [(0, "btn_homing"), (1, "btn_touch"), (3, "btn_tool"),
                    (7, "tbtn_fullsize_preview"), (9, "btn_exit")
                   ]
        self.h_tabs.append(tab_main)

        tab_mdi = [(9, "btn_show_kbd")]
        self.h_tabs.append(tab_mdi)

        tab_auto = [(0, "btn_load"), (1, "btn_run"), (2, "btn_stop"), (3, "tbtn_pause"),
                    (4, "btn_step"), (5, "btn_from_line"), (6, "tbtn_optional_blocks"),
                    (7, "tbtn_optional_stops"), (8, "tbtn_fullsize_preview1"), (9, "btn_edit")
                   ]
        self.h_tabs.append(tab_auto)

        tab_ref = [(1, "btn_home_all"), (3, "btn_home_x"),
                   (5, "btn_home_z"), (7, "btn_unhome_all"), (9, "btn_back_ref")
                  ]
        if not self.lathe_mode:
            tab_ref.append((4, "btn_home_y"))
        if len(self.axis_list) == 4:
            tab_ref.append((6, "btn_home_4"))
        self.h_tabs.append(tab_ref)

        tab_touch = [(0, "tbtn_edit_offsets"), (1, "btn_zero_x"), (3, "btn_zero_z"), (4, "btn_zero_g92"),
                     (5, "btn_set_value_x"), (7, "btn_set_value_z"), (8, "btn_set_selected"), (9, "btn_back_zero")
                    ]
        if not self.lathe_mode:
            tab_touch.append((2, "btn_zero_y"))
            tab_touch.append((6, "btn_set_value_y"))
        self.h_tabs.append(tab_touch)

        tab_setup = [(0, "btn_delete"), (4, "btn_classicladder"), (5, "btn_hal_scope"), (6, "btn_status"),
                     (7, "btn_hal_meter"), (8, "btn_calibration"), (9, "btn_show_hal")
                    ]
        self.h_tabs.append(tab_setup)

        tab_edit = [(0, "btn_open_edit"), (2, "btn_save"), (3, "btn_save_as"), (4, "btn_save_and_run"),
                    (6, "btn_new"), (8, "btn_keyb"), (9, "btn_back_edit")
                   ]
        self.h_tabs.append(tab_edit)

        tab_tool = [(0, "btn_delete_tool"), (1, "btn_add_tool"), (2, "btn_reload_tooltable"),
                    (3, "btn_apply_tool_changes"), (4, "btn_select_tool_by_no"), (5, "btn_index_tool"),
                    (6, "btn_change_tool"), (8, "btn_tool_touchoff_z"), (9, "btn_back_tool")
                   ]
        if self.lathe_mode:
            tab_tool.append((7, "btn_tool_touchoff_x"))
        self.h_tabs.append(tab_tool)

        tab_file = [(0, "btn_home"), (1, "btn_dir_up"), (3, "btn_sel_prev"), (4, "btn_sel_next"),
                    (5, "btn_jump_to"), (7, "btn_select"), (9, "btn_back_file_load")
                   ]
        self.h_tabs.append(tab_file)

        self.v_tabs = [(0, "tbtn_estop"), (1, "tbtn_on"), (2, "rbt_manual"), (3, "rbt_mdi"),
                       (4, "rbt_auto"), (5, "tbtn_setup"), (6, "tbtn_user_tabs")
                      ]

        # tool measurement probe settings
        xpos, ypos, zpos, maxprobe = self.get_ini_info.get_tool_sensor_data()
        if not xpos or not ypos or not zpos or not maxprobe:
            self.widgets.chk_use_tool_measurement.set_active(False)
            self.widgets.chk_use_tool_measurement.set_sensitive(False)
            self.widgets.btn_block_height.set_sensitive(False)
            self.widgets.lbl_tool_measurement.show()
            self.widgets.btn_zero_g92.show()
            self.widgets.btn_block_height.hide()
            print(_("**** GMOCCAPY INFO ****"))
            print(_("**** no valid probe config in INI File ****"))
            print(_("**** disabled tool measurement ****"))
        else:
            self.widgets.lbl_tool_measurement.hide()
            self.widgets.chk_use_tool_measurement.set_active(self.prefs.getpref("use_toolmeasurement", False, bool))
            self.widgets.spbtn_probe_height.set_value(self.prefs.getpref("probeheight", -1.0, float))
            self.widgets.spbtn_search_vel.set_value(self.prefs.getpref("searchvel", 75.0, float))
            self.widgets.spbtn_probe_vel.set_value(self.prefs.getpref("probevel", 10.0, float))
            self.widgets.lbl_x_probe.set_label(str(xpos))
            self.widgets.lbl_y_probe.set_label(str(ypos))
            self.widgets.lbl_z_probe.set_label(str(zpos))
            self.widgets.lbl_maxprobe.set_label(str(maxprobe))
            self.widgets.btn_block_height.set_sensitive(True)
            self.widgets.btn_zero_g92.hide()
            self.widgets.btn_block_height.show()
            self._replace_list_item(4, "btn_zero_g92", "btn_block_height")

        # and the rest of the widgets
        self.widgets.rbt_manual.set_active(True)
        self.widgets.ntb_jog.set_current_page(0)
        self.widgets.tbtn_optional_blocks.set_active(self.prefs.getpref("blockdel", False))
        self.command.set_block_delete(self.widgets.tbtn_optional_blocks.get_active())
        self.widgets.tbtn_optional_stops.set_active(not self.prefs.getpref("opstop", False))
        self.command.set_optional_stop(self.widgets.tbtn_optional_stops.get_active())
        self.log = self.prefs.getpref("log_actions", False, bool)
        self.widgets.tbtn_log_actions.set_active(self.log)
        self.widgets.chk_show_dro.set_active(self.prefs.getpref("enable_dro", False))
        self.widgets.chk_show_offsets.set_active(self.prefs.getpref("show_offsets", False))
        self.widgets.chk_show_dtg.set_active(self.prefs.getpref("show_dtg", False))
        self.widgets.chk_show_offsets.set_sensitive(self.widgets.chk_show_dro.get_active())
        self.widgets.chk_show_dtg.set_sensitive(self.widgets.chk_show_dro.get_active())
        self.widgets.cmb_mouse_button_mode.set_active(self.prefs.getpref("mouse_btn_mode", 4, int))

        self.widgets.tbtn_view_tool_path.set_active(self.prefs.getpref("view_tool_path", True))
        self.widgets.tbtn_view_dimension.set_active(self.prefs.getpref("view_dimension", True))
        view = self.prefs.getpref("gremlin_view", "rbt_view_p", str)
        self.widgets[view].set_active(True)

        # if the INI Config is valid, lets check further on, what to do
        if self.get_ini_info.get_embedded_tabs()[1]:
            if "ntb_preview" in self.get_ini_info.get_embedded_tabs()[1]:
                self.widgets.ntb_preview.set_property("show-tabs", True)

            # This is normaly only used for the plasma screen layout
            if "box_coolant_and_spindle" in self.get_ini_info.get_embedded_tabs()[1]:
                widgetlist = ["box_spindle", "box_cooling"]
                for widget in widgetlist:
                    self.widgets[widget].hide()
                self.widgets.tbtn_user_tabs.set_sensitive(False)

            if "box_cooling" in self.get_ini_info.get_embedded_tabs()[1]:
                widgetlist = ["frm_cooling"]
                for widget in widgetlist:
                    self.widgets[widget].hide()

            if "box_spindle" in self.get_ini_info.get_embedded_tabs()[1]:
                widgetlist = ["frm_spindle"]
                for widget in widgetlist:
                    self.widgets[widget].hide()

            if "box_vel_info" in self.get_ini_info.get_embedded_tabs()[1]:
                widgetlist = ["frm_max_vel", "frm_feed_override"]
                for widget in widgetlist:
                    self.widgets[widget].hide()

            if "box_custom_1" in self.get_ini_info.get_embedded_tabs()[1]:
                self.widgets.box_custom_1.show()

            if "box_custom_2" in self.get_ini_info.get_embedded_tabs()[1]:
                self.widgets.box_custom_2.show()

            if "box_custom_3" in self.get_ini_info.get_embedded_tabs()[1]:
                self.widgets.box_custom_3.show()

            if "box_custom_4" in self.get_ini_info.get_embedded_tabs()[1]:
                self.widgets.box_custom_4.show()

            if "box_tool_and_code_info" in self.get_ini_info.get_embedded_tabs()[1]:
                widgetlist = ["frm_tool_info", "active_speed_label", "lbl_speed", "box_vel_info"]
                for widget in widgetlist:
                    self.widgets[widget].hide()
                self.widgets.btn_tool.set_sensitive(False)
                self.widgets.tbtn_user_tabs.set_sensitive(False)

        # get if run from line should be used
        rfl = self.prefs.getpref("run_from_line", "no_run", str)
        # and set the corresponding button active
        self.widgets["rbtn_%s_from_line" % rfl].set_active(True)
        if rfl == "no_run":
            self.widgets.btn_from_line.set_sensitive(False)
        else:
            self.widgets.btn_from_line.set_sensitive(True)

        # get the way to unlock the settings
        unlock = self.prefs.getpref("unlock_way", "use", str)
        # and set the corresponding button active
        self.widgets["rbt_%s_unlock" % unlock].set_active(True)
        # if Hal pin should be used, only set the button active, if the pin is high
        if unlock == "hal" and not self.halcomp["unlock-settings"]:
            self.widgets.tbtn_setup.set_sensitive(False)
        self.unlock_code = self.prefs.getpref("unlock_code", "123", str) # get unlock code

        # get when the keyboard should be shown
        # and set the corresponding button active
        self.widgets.chk_use_kb_on_offset.set_active(self.prefs.getpref("show_keyboard_on_offset",
                                                                             True, bool))
        self.widgets.chk_use_kb_on_tooledit.set_active(self.prefs.getpref("show_keyboard_on_tooledit",
                                                                             False, bool))
        self.widgets.chk_use_kb_on_edit.set_active(self.prefs.getpref("show_keyboard_on_edit",
                                                                              True, bool))
        self.widgets.chk_use_kb_on_mdi.set_active(self.prefs.getpref("show_keyboard_on_mdi",
                                                                             True, bool))
        self.widgets.chk_use_kb_on_file_selection.set_active(self.prefs.getpref("show_keyboard_on_file_selection",
                                                                             False, bool))

        # check if the user want to display preview window insteadt of offsetpage widget
        state = self.prefs.getpref("show_preview_on_offset", False, bool)
        if state:
            self.widgets.rbtn_show_preview.set_active(True)
        else:
            self.widgets.rbtn_show_offsets.set_active(True)

        # check if keyboard shortcuts should be used and set the chkbox widget
        self.widgets.chk_use_kb_shortcuts.set_active(self.prefs.getpref("use_keyboard_shortcuts",
                                                                                False, bool))

        # check the highlighting type
        # the following would load the python language
        # self.widgets.gcode_view.set_language("python")
        LANGDIR = os.path.join(BASE, "share", "gtksourceview-2.0", "language-specs")
        file_path = os.path.join(LANGDIR, "gcode.lang")
        if os.path.isfile(file_path):
            print "******************************* Gcode.lang found"
            self.widgets.gcode_view.set_language("gcode", LANGDIR)

        # set the user colors of the DRO
        self.abs_color = self.prefs.getpref("abs_color", "blue", str)
        self.rel_color = self.prefs.getpref("rel_color", "black", str)
        self.dtg_color = self.prefs.getpref("dtg_color", "yellow", str)
        self.homed_color = self.prefs.getpref("homed_color", "green", str)
        self.unhomed_color = self.prefs.getpref("unhomed_color", "red", str)
        self.widgets.abs_colorbutton.set_color(gtk.gdk.color_parse(self.abs_color))
        self.widgets.rel_colorbutton.set_color(gtk.gdk.color_parse(self.rel_color))
        self.widgets.dtg_colorbutton.set_color(gtk.gdk.color_parse(self.dtg_color))
        self.widgets.homed_colorbtn.set_color(gtk.gdk.color_parse(self.homed_color))
        self.widgets.unhomed_colorbtn.set_color(gtk.gdk.color_parse(self.unhomed_color))

        for axis in self.axis_list:
            if axis == self.axisletter_four:
                axis = 4
            self.widgets["Combi_DRO_%s" % axis].set_property("abs_color", gtk.gdk.color_parse(self.abs_color))
            self.widgets["Combi_DRO_%s" % axis].set_property("rel_color", gtk.gdk.color_parse(self.rel_color))
            self.widgets["Combi_DRO_%s" % axis].set_property("dtg_color", gtk.gdk.color_parse(self.dtg_color))
            self.widgets["Combi_DRO_%s" % axis].set_property("homed_color", gtk.gdk.color_parse(self.homed_color))
            self.widgets["Combi_DRO_%s" % axis].set_property("unhomed_color", gtk.gdk.color_parse(self.unhomed_color))

        self.widgets.adj_start_spindle_RPM.set_value(self.spindle_start_rpm)
        self.widgets.gcode_view.set_sensitive(False)
        self.tooledit_btn_delete_tool = self.widgets.tooledit1.wTree.get_object("delete")
        self.tooledit_btn_add_tool = self.widgets.tooledit1.wTree.get_object("add")
        self.tooledit_btn_reload_tool = self.widgets.tooledit1.wTree.get_object("reload")
        self.tooledit_btn_apply_tool = self.widgets.tooledit1.wTree.get_object("apply")
        self.widgets.tooledit1.hide_buttonbox(True)
        self.widgets.ntb_user_tabs.remove_page(0)
        self._add_macro_button()

        if not self.get_ini_info.get_embedded_tabs()[2]:
            self.widgets.tbtn_user_tabs.set_sensitive(False)

        # call the function to change the button status
        # so every thing is ready to start
        widgetlist = ["rbt_manual", "rbt_mdi", "rbt_auto", "btn_homing", "btn_touch", "btn_tool",
                      "ntb_jog", "scl_feed", "btn_feed_100", "rbt_forward", "btn_index_tool",
                      "rbt_reverse", "rbt_stop", "tbtn_flood", "tbtn_mist", "btn_change_tool",
                      "btn_select_tool_by_no", "btn_spindle_100", "scl_max_vel", "scl_spindle",
                      "btn_tool_touchoff_x", "btn_tool_touchoff_z"
                     ]
        self._sensitize_widgets(widgetlist, False)

        # Do we control a lathe?
        if self.lathe_mode:
            # is this a backtool lathe?
            self.backtool_lathe = self.get_ini_info.get_backtool_lathe()

            # we first hide the Y button to home and touch off
            self.widgets.btn_home_y.hide()
            self.widgets.btn_zero_y.hide()
            self.widgets.btn_set_value_y.hide()
            self.widgets.lbl_replace_y.show()
            self.widgets.lbl_replace_zero_y.show()
            self.widgets.lbl_replace_set_value_y.show()
            self.widgets.btn_tool_touchoff_x.show()
            self.widgets.lbl_hide_tto_x.hide()

            # we have to re-arrange the jog buttons, so first remove all button
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_y_minus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_y_plus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_x_minus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_x_plus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_z_minus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_z_plus)

            # now we place them in a different order
            if self.backtool_lathe:
                self.widgets.tbl_jog_btn.attach(self.widgets.btn_x_plus, 1, 2, 0, 1, gtk.SHRINK, gtk.SHRINK)
                self.widgets.tbl_jog_btn.attach(self.widgets.btn_x_minus, 1, 2, 2, 3, gtk.SHRINK, gtk.SHRINK)
            else:
                self.widgets.tbl_jog_btn.attach(self.widgets.btn_x_plus, 1, 2, 2, 3, gtk.SHRINK, gtk.SHRINK)
                self.widgets.tbl_jog_btn.attach(self.widgets.btn_x_minus, 1, 2, 0, 1, gtk.SHRINK, gtk.SHRINK)
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_z_plus, 2, 3, 1, 2, gtk.SHRINK, gtk.SHRINK)
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_z_minus, 0, 1, 1, 2, gtk.SHRINK, gtk.SHRINK)

            # The Y DRO we make to a second X DRO to indicate the diameter
            self.widgets.Combi_DRO_y.set_to_diameter(True)
            self.widgets.Combi_DRO_y.set_property("joint_number", 0)

            # we change the axis letters of the DRO's
            self.widgets.Combi_DRO_x.change_axisletter("R")
            self.widgets.Combi_DRO_y.change_axisletter("D")

            # and we will have to change the colors of the Y DRO according to the settings
            self.widgets.Combi_DRO_y.set_property("abs_color", gtk.gdk.color_parse(self.abs_color))
            self.widgets.Combi_DRO_y.set_property("rel_color", gtk.gdk.color_parse(self.rel_color))
            self.widgets.Combi_DRO_y.set_property("dtg_color", gtk.gdk.color_parse(self.dtg_color))
            self.widgets.Combi_DRO_y.set_property("homed_color", gtk.gdk.color_parse(self.homed_color))
            self.widgets.Combi_DRO_y.set_property("unhomed_color", gtk.gdk.color_parse(self.unhomed_color))

            # For gremlin we don"t need the following button
            if self.backtool_lathe:
                self.widgets.rbt_view_y2.set_active(True)
            else:
                self.widgets.rbt_view_y.set_active(True)
            self.widgets.rbt_view_p.hide()
            self.widgets.rbt_view_x.hide()
            self.widgets.rbt_view_z.hide()

            # check if G7 or G8 is active
            # this is set on purpose wrong, because we want the periodic
            # to update the state correctly
            if "70" in self.stat.gcodes:
                self.diameter_mode = False
            else:
                self.diameter_mode = True

        else:
            # the Y2 view is not needed on a mill
            self.widgets.rbt_view_y2.hide()
            # X Offset is not necesary on a mill
            self.widgets.lbl_tool_offset_x.hide()
            self.widgets.lbl_offset_x.hide()
            self.widgets.btn_tool_touchoff_x.hide()
            self.widgets.lbl_hide_tto_x.show()

        # this must be done last, otherwise we will get wrong values
        # because the window is not fully realized
        self.init_notification()

        # since the main loop is needed to handle the UI and its events, blocking calls like sleep()
        # will block the UI as well, so everything goes through event handlers (aka callbacks)
        # The gobject.timeout_add() function sets a function to be called at regular intervals
        # the time between calls to the function, in milliseconds
        gobject.timeout_add(100, self._periodic) # time between calls to the function, in milliseconds

    def _get_axis_list (self):
        temp = self.get_ini_info.get_coordinates()
        self.axis_list = []
        for letter in temp:
            if letter.lower() in self.axis_list:
                continue
            if not letter.lower() in ["x", "y", "z", "a", "b", "c", "u", "v", "w"]:
                continue
            self.axis_list.append(letter.lower())

    def _init_preferences(self):
        # check if NO_FORCE_HOMING is used in ini
        self.no_force_homing = self.get_ini_info.get_no_force_homing()
        self.spindle_start_rpm = self.prefs.getpref('spindle_start_rpm', 300 , float)
        # if it's a lathe config, set the tooleditor style
        self.lathe_mode = self.get_ini_info.get_lathe()
        self.jog_rate = self.get_ini_info.get_jog_vel()
        self.jog_rate_max = self.get_ini_info.get_max_jog_vel()
        self.spindle_override_max = self.get_ini_info.get_max_spindle_override()
        self.spindle_override_min = self.get_ini_info.get_min_spindle_override()
        self.feed_override_max = self.get_ini_info.get_max_feed_override()

        # set the slider limmits
        self.widgets.adj_max_vel.configure(self.stat.max_velocity * 60, 0.0,
                                           self.stat.max_velocity * 60 , 1, 0, 0)
        self.widgets.adj_jog_vel.configure(self.jog_rate, 0,
                                           self.jog_rate_max , 1, 0, 0)
        self.widgets.adj_spindle.configure(100, self.spindle_override_min * 100,
                                           self.spindle_override_max * 100, 1, 0, 0)
        self.widgets.adj_feed.configure(100, 0, self.feed_override_max * 100, 1, 0, 0)

        # and according to machine units the digits to display
        if self.stat.linear_units == _MM:
            self.widgets.scl_max_vel.set_digits(0)
            self.widgets.scl_jog_vel.set_digits(0)
        else:
            self.widgets.scl_max_vel.set_digits(3)
            self.widgets.scl_jog_vel.set_digits(3)

        # the scale to apply to the count of the hardware mpg wheel, to avoid to much turning
        default = (self.stat.max_velocity * 60 - self.stat.max_velocity * 0.1) / 100
        self.scale_max_vel = self.prefs.getpref("scale_max_vel", default, float)
        self.widgets.adj_scale_max_vel.set_value(self.scale_max_vel)
        default = (self.jog_rate_max / 100)
        self.scale_jog_vel = self.prefs.getpref("scale_jog_vel", default, float)
        self.widgets.adj_scale_jog_vel.set_value(self.scale_jog_vel)
        self.scale_spindle_override = self.prefs.getpref("scale_spindle_override", 1, float)
        self.widgets.adj_scale_spindle_override.set_value(self.scale_spindle_override)
        self.scale_feed_override = self.prefs.getpref("scale_feed_override", 1, float)
        self.widgets.adj_scale_feed_override.set_value(self.scale_feed_override)

    def _init_axis_four(self):
        self.dro_size = int(self.prefs.getpref("dro_size", 28, int))
        self.widgets.adj_dro_size.set_value(self.dro_size)

        if len(self.axis_list) < 4:
            self.widgets.Combi_DRO_4.hide()
            self.widgets.chk_hide_axis_4.set_active(False)
            self.widgets.frm_tool_changer.set_sensitive(False)
            self.prefs.putpref("hide_axis_4", False, bool)

            for axis in self.axis_list:
                self.widgets["Combi_DRO_%s" % axis].set_property("font_size", self.dro_size)

            return
        axis_four = list(set(self.axis_list) - set(("x", "y", "z")))
        if len(axis_four) > 1:
            message = _("**** GMOCCAPY INFO : ****")
            message += _("**** gmoccapy can only handle 4 axis, ****\n**** but you have given %d through your INI file ****\n" % len(self.axis_list))
            message += _("**** gmoccapy will not start ****\n\n")
            print(message)
            self.widgets.window1.destroy()
        self.axisletter_four = axis_four[0]
        self.axisnumber_four = "xyzabcuvw".index(self.axisletter_four)
        self.widgets.Combi_DRO_4.set_property("joint_number", self.axisnumber_four)
        self.widgets.Combi_DRO_4.change_axisletter(self.axisletter_four.upper())
        if self.axisletter_four in "abc":
            self.widgets.Combi_DRO_4.set_property("mm_text_template", "%11.2f")
            self.widgets.Combi_DRO_4.set_property("imperial_text_template", "%11.2f")
        image = self.widgets["img_home_%s" % self.axisletter_four]
        self.widgets.btn_home_4.set_image(image)
        self.widgets.btn_home_4.set_property("tooltip-text", _("Home axis %s") % self.axisletter_four.upper())

        # We have to change the size of the DRO, to make 4 DRO fit the space we got
        for axis in self.axis_list:
            if axis == self.axisletter_four:
                axis = 4
            self.widgets["Combi_DRO_%s" % axis].set_property("font_size", self.dro_size * 3 / 4)

        self.widgets.btn_4_plus.set_label("%s+" % self.axisletter_four.upper())
        self.widgets.btn_4_minus.set_label("%s-" % self.axisletter_four.upper())
        self.widgets.btn_4_plus.show()
        self.widgets.btn_4_minus.show()
        self.widgets.lbl_replace_4.hide()
        self.widgets.btn_home_4.show()

        # we have to re-arrange the jog buttons, so first remove all button
        self.widgets.tbl_jog_btn.remove(self.widgets.btn_z_minus)
        self.widgets.tbl_jog_btn.remove(self.widgets.btn_z_plus)
        self.widgets.tbl_jog_btn.remove(self.widgets.btn_4_minus)
        self.widgets.tbl_jog_btn.remove(self.widgets.btn_4_plus)

        # now we place them in a different order
        self.widgets.tbl_jog_btn.attach(self.widgets.btn_z_plus, 2, 3, 0, 1, gtk.SHRINK, gtk.SHRINK)
        self.widgets.tbl_jog_btn.attach(self.widgets.btn_z_minus, 2, 3, 2, 3, gtk.SHRINK, gtk.SHRINK)
        self.widgets.tbl_jog_btn.attach(self.widgets.btn_4_plus, 3, 4, 0, 1, gtk.SHRINK, gtk.SHRINK)
        self.widgets.tbl_jog_btn.attach(self.widgets.btn_4_minus, 3, 4, 2, 3, gtk.SHRINK, gtk.SHRINK)

        if self.prefs.getpref("hide_axis_4", False, bool):
            self._hide_axis_4(True)

    def _hide_axis_4(self, state = False):
        print("axis 4 should be hidden", state)

        # we save the state, because it will be needed also
        # in _init_offsetpage and _init_tooleditor
        self.hide_axis_4 = state

        self.widgets.chk_hide_axis_4.set_active(self.hide_axis_4)

        if self.hide_axis_4:
            self.widgets.frm_tool_changer.set_sensitive(True)
            self.widgets.Combi_DRO_4.hide()
            self.widgets.btn_4_plus.hide()
            self.widgets.btn_4_minus.hide()
            font_size = self.dro_size

            # we have to re-arrange the jog buttons, so first remove all button
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_z_minus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_z_plus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_4_minus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_4_plus)

            # now we place them in a different order
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_z_plus, 3, 4, 0, 1, gtk.SHRINK, gtk.SHRINK)
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_z_minus, 3, 4, 2, 3, gtk.SHRINK, gtk.SHRINK)
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_4_plus, 3, 4, 0, 1, gtk.SHRINK, gtk.SHRINK)
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_4_minus, 3, 4, 2, 3, gtk.SHRINK, gtk.SHRINK)

            self.widgets.btn_4_plus.hide()
            self.widgets.btn_4_minus.hide()
            self.widgets.lbl_replace_4.show()
            self.widgets.btn_home_4.hide()

        else:
            font_size = self.dro_size * 3 / 4

            # we have to re-arrange the jog buttons, so first remove all button
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_z_minus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_z_plus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_4_minus)
            self.widgets.tbl_jog_btn.remove(self.widgets.btn_4_plus)

            # now we place them in a different order
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_z_plus, 2, 3, 0, 1, gtk.SHRINK, gtk.SHRINK)
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_z_minus, 2, 3, 2, 3, gtk.SHRINK, gtk.SHRINK)
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_4_plus, 3, 4, 0, 1, gtk.SHRINK, gtk.SHRINK)
            self.widgets.tbl_jog_btn.attach(self.widgets.btn_4_minus, 3, 4, 2, 3, gtk.SHRINK, gtk.SHRINK)

            self.widgets.btn_4_plus.show()
            self.widgets.btn_4_minus.show()
            self.widgets.lbl_replace_4.hide()
            self.widgets.btn_home_4.show()
            self.widgets.Combi_DRO_4.show()

        for axis in self.axis_list:
            if axis == self.axisletter_four:
                axis = 4
            self.widgets["Combi_DRO_%s" % axis].set_property("font_size", font_size)

    def _init_jog_increments(self):
        # Now we will build the option buttons to select the Jog-rates
        # We do this dynamicly, because users are able to set them in INI File
        # because of space on the screen only 10 items are allowed
        # jogging increments

        # We get the increments from INI File
        self.jog_increments = self.get_ini_info.get_increments()
        if len(self.jog_increments) > 10:
            print(_("**** GMOCCAPY INFO ****"))
            print(_("**** To many increments given in INI File for this screen ****"))
            print(_("**** Only the first 10 will be reachable through this screen ****"))
            # we shorten the incrementlist to 10 (first is default = 0)
            self.jog_increments = self.jog_increments[0:11]

        # The first radio button is created to get a radio button group
        # The group is called according the name off  the first button
        # We use the pressed signal, not the toggled, otherwise two signals will be emitted
        # One from the released button and one from the pressed button
        # we make a list of the buttons to later add the hardware pins to them
        label = _("Continuous")
        rbt0 = gtk.RadioButton(None, label)
        rbt0.connect("pressed", self.on_increment_changed, 0)
        self.widgets.vbuttonbox2.pack_start(rbt0, True, True, 0)
        rbt0.set_property("draw_indicator", False)
        rbt0.show()
        self.incr_rbt_list.append(rbt0)
        # the rest of the buttons are now added to the group
        # self.no_increments is set while setting the hal pins with self._check_len_increments
        for item in range(1, len(self.jog_increments)):
            rbt = "rbt%d" % (item)
            rbt = gtk.RadioButton(rbt0, self.jog_increments[item])
            rbt.connect("pressed", self.on_increment_changed, self.jog_increments[item])
            self.widgets.vbuttonbox2.pack_start(rbt, True, True, 0)
            rbt.set_property("draw_indicator", False)
            rbt.show()
            self.incr_rbt_list.append(rbt)

    def _check_screen2(self):
        # second screen
        self.screen2 = False
        screen2 = os.path.join(CONFIGPATH, "gmoccapy2.glade")
        if os.path.exists(screen2):
            print (_("**** GMOCCAPY INFO ****"))
            print (_("**** gmoccapy screen 2 found ****"))
            try:
                self.builder.add_from_file(screen2)
                self.screen2 = True
            except Exception, e:
                print (_("**** GMOCCAPY ERROR ****"))
                print _("**** screen 2 GLADE ERROR: ****")
                self.widgets.tbtn_use_screen2.set_sensitive(False)
                traceback.print_exc()
        else:
            print (_("**** GMOCCAPY INFO ****"))
            print _("**** No gmoccapy2.glade file present ****")
            self.widgets.tbtn_use_screen2.set_sensitive(False)

# =============================================================
# Dynamic tabs handling Start
    def _init_dynamic_tabs(self):
        # dynamic tabs setup
        self._dynamic_childs = {}
        # register all tabs, so they will be closed together with the GUI
        atexit.register(self._kill_dynamic_childs)

        tab_names, tab_location, tab_cmd = self.get_ini_info.get_embedded_tabs()
        if not tab_names:
            print (_("**** GMOCCAPY ERROR ****"))
            print (_("**** Invalid embeded tab configuration ****"))
            print (_("**** No tabs will be added! ****"))
            return

        for t, c , name in zip(tab_names, tab_cmd, tab_location):
            nb = self.widgets[name]
            xid = self._dynamic_tab(nb, t)
            if not xid: continue
            cmd = c.replace('{XID}', str(xid))
            child = subprocess.Popen(cmd.split())
            self._dynamic_childs[xid] = child
            nb.show_all()

    # adds the embedded object to a notebook tab or box
    def _dynamic_tab(self, widget, text):
        s = gtk.Socket()
        try:
            widget.append_page(s, gtk.Label(" " + text + " "))
        except:
            try:
                widget.pack_end(s, True, True, 0)
            except:
                return None
        return s.get_id()

    # Gotta kill the embedded processes when gmoccapy closes
    def _kill_dynamic_childs(self):
        for child in self._dynamic_childs.values():
            child.terminate()

# Dynamic tabs handling End
# =============================================================

    # first we hide all the axis columns the unhide the ones we want
    # if it's a lathe config we show lathe related columns
    # and we load the tooltable data
    def _init_tooleditor(self):
        self.widgets.tooledit1.set_visible("abcxyzuvwijq", False)
        for axis in self.axis_list:
            if axis == self.axisletter_four:
                if self.hide_axis_4:
                    continue
            self.widgets.tooledit1.set_visible("%s" % axis, True)

        if self.lathe_mode:
            self.widgets.tooledit1.set_visible("ijq", True)
        # get the path to the tool table
        tooltable = self.get_ini_info.get_toolfile()
        if not tooltable:
            print(_("**** GMOCCAPY ERROR ****"))
            print(_("**** Did not find a toolfile file in [EMCIO] TOOL_TABLE ****"))
            sys.exit()
        toolfile = os.path.join(CONFIGPATH, tooltable)
        self.widgets.tooledit1.set_filename(toolfile)

    def _init_embeded_terminal(self):
        # add terminal window
        self.widgets._terminal = vte.Terminal ()
        self.widgets._terminal.connect ("child-exited", lambda term: gtk.main_quit())
        self.widgets._terminal.fork_command()
        self.widgets._terminal.show()
        window = self.widgets.terminal_window.add(self.widgets._terminal)
        self.widgets.terminal_window.connect('delete-event', lambda window, event: gtk.main_quit())
        self.widgets.terminal_window.show()

    def _init_themes(self):
        # If there are themes then add them to combo box
        if os.path.exists(THEMEDIR):
            model = self.widgets.theme_choice.get_model()
            model.clear()
            model.append(("Follow System Theme",))
            temp = 0
            names = os.listdir(THEMEDIR)
            names.sort()
            theme_name = self.prefs.getpref("gtk_theme", "Follow System Theme", str)
            for search, dirs in enumerate(names):
                model.append((dirs,))
                if dirs == theme_name:
                    temp = search + 1
            self.widgets.theme_choice.set_active(temp)
        settings = gtk.settings_get_default()
        if not theme_name == "Follow System Theme":
            settings.set_string_property("gtk-theme-name", theme_name, "")

    def _init_audio(self):
        # try to add ability for audio feedback to user.
        self._AUDIO_AVAILABLE = False
        try:
            import gst
            self._AUDIO_AVAILABLE = True
            print (_("**** GMOCCAPY INFO ****"))
            print (_("**** audio available! ****"))
        except:
            print (_("**** GMOCCAPY INFO ****"))
            print (_("**** no audio available! ****"))
            print(_("**** PYGST libray not installed? ****"))
            return

        if self._AUDIO_AVAILABLE:
            self.audio = player.Player()
            self.alert_sound = self.prefs.getpref('audio_alert', self.alert_sound, str)
            self.error_sound = self.prefs.getpref('audio_error', self.error_sound, str)
            self.widgets.audio_alert_chooser.set_filename(self.alert_sound)
            self.widgets.audio_error_chooser.set_filename(self.error_sound)
        else:
            self.widgets.audio_alert_chooser.set_sensitiv(False)
            self.widgets.audio_error_chooser.set_sensitiv(False)

    # init the preview
    def _init_gremlin(self):
        grid_size = self.prefs.getpref('grid_size', 1.0 , float)
        self.widgets.grid_size.set_value(grid_size)
        self.widgets.gremlin.grid_size = grid_size
        view = self.prefs.getpref('view', "p", str)
        self.widgets.gremlin.set_property("view", view)
        self.widgets.gremlin.set_property("metric_units", int(self.stat.linear_units))
        self.widgets.gremlin.set_property("mouse_btn_mode", self.prefs.getpref("mouse_btn_mode", 4, int))

    # init the function to hide the cursor
    def _init_hide_cursor(self):
        hide_cursor = self.prefs.getpref('hide_cursor', False, bool)
        self.widgets.chk_hide_cursor.set_active(hide_cursor)
        # if hide cursor requested
        # we set the graphics to use touchscreen controls
        if hide_cursor:
            self.widgets.window1.window.set_cursor(INVISABLE)
            self.widgets.gremlin.set_property("use_default_controls", False)
        else:
            self.widgets.window1.window.set_cursor(None)
            self.widgets.gremlin.set_property("use_default_controls", True)

# =============================================================
# Onboard keybord handling Start

    # shows "Onboard" virtual keyboard if available
    # else error message
    def _init_keyboard(self, args = "", x = "", y = ""):
        try:
            self.onboard_kb = subprocess.Popen(["onboard", "--xid", args, x, y],
                                   stdin = subprocess.PIPE,
                                   stdout = subprocess.PIPE,
                                   close_fds = True)
            sid = self.onboard_kb.stdout.readline()
            # print"keyboard", sid # skip header line
            socket = gtk.Socket()
            socket.show()
            self.widgets.key_box.add(socket)
            socket.add_id(long(sid))
        except Exception, e:
            print (_("**** GMOCCAPY ERROR ****"))
            print (_("**** Error with launching 'Onboard' on-screen keyboard program,"))
            print (_("**** is onboard installed? ****"))
            traceback.print_exc()

    def _kill_keyboard(self):
        try:
            self.onboard_kb.kill()
            self.onboard_kb.terminate()
            self.onboard_kb = None
        except:
            try:
                self.onboard_kb.kill()
                self.onboard_kb.terminate()
                self.onboard_kb = None
            except:
                pass

# Onboard keybord handling End
# =============================================================

    def _init_offsetpage(self):
        temp = "xyzabcuvw"
        self.widgets.offsetpage1.set_col_visible(temp, False)
        temp = ""
        for axis in self.axis_list:
            if axis == self.axisletter_four:
                if self.hide_axis_4:
                    continue
            temp = temp + axis
        self.widgets.offsetpage1.set_col_visible(temp, True)

        parameterfile = self.get_ini_info.get_parameter_file()
        if not parameterfile:
            print(_("**** GMOCCAPY ERROR ****"))
            print(_("**** Did not find a parameter file in [RS274NGC] PARAMETER_FILE ****"))
            sys.exit()
        path = os.path.join(CONFIGPATH, parameterfile)
        self.widgets.offsetpage1.set_filename(path)

        self.widgets.offsetpage1.set_display_follows_program_units()
        if self.stat.program_units != 1:
            self.widgets.offsetpage1.set_to_mm()
            self.widgets.offsetpage1.machine_units_mm = _MM
        else:
            self.widgets.offsetpage1.set_to_inch()
            self.widgets.offsetpage1.machine_units_mm = _INCH
        self.widgets.offsetpage1.hide_buttonbox(True)
        self.widgets.offsetpage1.set_row_visible("1", False)
        self.widgets.offsetpage1.set_font("sans 12")
        self.widgets.offsetpage1.set_foreground_color("#28D0D9")
        self.widgets.offsetpage1.selection_mask = ("Tool", "G5x", "Rot")
        systemlist = ["Tool", "G5x", "Rot", "G92", "G54", "G55", "G56", "G57", "G58", "G59", "G59.1",
                   "G59.2", "G59.3"]
        names = []
        for system in systemlist:
            system_name = "system_name_%s" % system
            name = self.prefs.getpref(system_name, system, str)
            names.append([system, name])
        self.widgets.offsetpage1.set_names(names)

    # Icon file selection stuff
    def _init_IconFileSelection(self):
        self.widgets.IconFileSelection1.set_property("start_dir", self.get_ini_info.get_program_prefix())

        iconsize = 48
        self.widgets.IconFileSelection1.set_property("icon_size", iconsize)

        file_ext = self.get_ini_info.get_file_ext()
        filetypes = ""
        for ext in file_ext:
            filetypes += ext.replace("*.", "") + ","
        self.widgets.IconFileSelection1.set_property("filetypes", filetypes)

        jump_to_dir = self.prefs.getpref("jump_to_dir", os.path.expanduser("~"), str)
        self.widgets.jump_to_dir_chooser.set_current_folder(jump_to_dir)
        self.widgets.IconFileSelection1.set_property("jump_to_dir", jump_to_dir)

        self.widgets.IconFileSelection1.show_buttonbox(False)
        self.widgets.IconFileSelection1.show_filelabel(False)

    # init the keyboard shortcut bindings
    def _init_keybindings(self):
        try:
            accel_group = gtk.AccelGroup()
            self.widgets.window1.add_accel_group(accel_group)
            self.widgets.button_estop.add_accelerator("clicked", accel_group, 65307, 0, gtk.ACCEL_LOCKED)
        except:
            pass
        self.widgets.window1.connect("key_press_event", self.on_key_event, 1)
        self.widgets.window1.connect("key_release_event", self.on_key_event, 0)

    # Initialize the file to load dialog, setting an title and the correct
    # folder as well as a file filter
    def _init_file_to_load(self):
        file_dir = self.get_ini_info.get_program_prefix()
        self.widgets.file_to_load_chooser.set_current_folder(file_dir)
        title = _("Select the file you want to be loaded at program start")
        self.widgets.file_to_load_chooser.set_title(title)
        self.widgets.ff_file_to_load.set_name("linuxcnc files")
        self.widgets.ff_file_to_load.add_pattern("*.ngc")
        file_ext = self.get_ini_info.get_file_ext()
        for ext in file_ext:
            self.widgets.ff_file_to_load.add_pattern(ext)

    def _show_offset_tab(self, state):
        page = self.widgets.ntb_preview.get_nth_page(1)
        if page.get_visible()and state or not page.get_visible()and not state:
            return
        if state:
            page.show()
            self.widgets.ntb_preview.set_property("show-tabs", state)
            self.widgets.ntb_preview.set_current_page(1)
            self.widgets.offsetpage1.mark_active((self.system_list[self.stat.g5x_index]).lower())
            if self.widgets.chk_use_kb_on_offset.get_active():
                self.widgets.ntb_info.set_current_page(1)
        else:
            names = self.widgets.offsetpage1.get_names()
            for system, name in names:
                system_name = "system_name_%s" % system
                self.prefs.putpref(system_name, name, str)
            page.hide()
            self.widgets.tbtn_edit_offsets.set_active(False)
            self.widgets.ntb_preview.set_current_page(0)
            self.widgets.ntb_info.set_current_page(0)
            if self.widgets.ntb_preview.get_n_pages() <= 4: # else user tabs are availible
                self.widgets.ntb_preview.set_property("show-tabs", state)

    def _show_tooledit_tab(self, state):
        page = self.widgets.ntb_preview.get_nth_page(2)
        if page.get_visible()and state or not page.get_visible()and not state:
            return
        if state:
            page.show()
            self.widgets.ntb_preview.set_property("show-tabs", not state)
            self.widgets.vbx_jog.hide()
            self.widgets.ntb_preview.set_current_page(2)
            self.widgets.tooledit1.set_selected_tool(self.stat.tool_in_spindle)
            if self.widgets.chk_use_kb_on_tooledit.get_active():
                self.widgets.ntb_info.set_current_page(1)
        else:
            page.hide()
            if self.widgets.ntb_preview.get_n_pages() > 4: # user tabs are availible
                self.widgets.ntb_preview.set_property("show-tabs", not state)
            self.widgets.vbx_jog.show()
            self.widgets.ntb_preview.set_current_page(0)
            self.widgets.ntb_info.set_current_page(0)

    def _show_iconview_tab(self, state):
        page = self.widgets.ntb_preview.get_nth_page(3)
        if page.get_visible()and state or not page.get_visible()and not state:
            return
        if state:
            page.show()
            self.widgets.ntb_preview.set_property("show-tabs", not state)
            self.widgets.ntb_preview.set_current_page(3)
            if self.widgets.chk_use_kb_on_file_selection.get_active():
                self.widgets.box_info.show()
                self.widgets.ntb_info.set_current_page(1)
        else:
            page.hide()
            if self.widgets.ntb_preview.get_n_pages() > 4: # user tabs are availible
                self.widgets.ntb_preview.set_property("show-tabs", not state)
            self.widgets.ntb_preview.set_current_page(0)
            self.widgets.ntb_info.set_current_page(0)

    # every 100 milli seconds this gets called
    # check linuxcnc for status, error and then update the readout
    def _periodic(self):
        self.stat.poll()
        error = self.error_channel.poll()
        if error:
            self._show_error(error)

        if self.gcodes != self.stat.gcodes:
            self._update_active_gcodes()
        if self.mcodes != self.stat.mcodes:
            self._update_active_mcodes()

        if self.lathe_mode:
            if "G8" in self.active_gcodes and self.diameter_mode:
                self.widgets.Combi_DRO_y.set_property("abs_color", gtk.gdk.color_parse("#F2F1F0"))
                self.widgets.Combi_DRO_y.set_property("rel_color", gtk.gdk.color_parse("#F2F1F0"))
                self.widgets.Combi_DRO_y.set_property("dtg_color", gtk.gdk.color_parse("#F2F1F0"))
                self.widgets.Combi_DRO_x.set_property("abs_color", gtk.gdk.color_parse(self.abs_color))
                self.widgets.Combi_DRO_x.set_property("rel_color", gtk.gdk.color_parse(self.rel_color))
                self.widgets.Combi_DRO_x.set_property("dtg_color", gtk.gdk.color_parse(self.dtg_color))
                self.diameter_mode = False
            elif "G7" in self.active_gcodes and not self.diameter_mode:
                self.widgets.Combi_DRO_x.set_property("abs_color", gtk.gdk.color_parse("#F2F1F0"))
                self.widgets.Combi_DRO_x.set_property("rel_color", gtk.gdk.color_parse("#F2F1F0"))
                self.widgets.Combi_DRO_x.set_property("dtg_color", gtk.gdk.color_parse("#F2F1F0"))
                self.widgets.Combi_DRO_y.set_property("abs_color", gtk.gdk.color_parse(self.abs_color))
                self.widgets.Combi_DRO_y.set_property("rel_color", gtk.gdk.color_parse(self.rel_color))
                self.widgets.Combi_DRO_y.set_property("dtg_color", gtk.gdk.color_parse(self.dtg_color))
                self.diameter_mode = True

        self._update_vel()
        self._update_coolant()
        self._update_spindle_btn()

        # keep the timer running
        return True

    def _show_error(self, error):
        kind, text = error
        # print kind,text
        if "joint" in text:
            for letter in self.axis_list:
                axnum = "xyzabcuvws".index(letter)
                text = text.replace("joint %d" % axnum, "Axis %s" % letter.upper())
        if kind in (linuxcnc.NML_ERROR, linuxcnc.OPERATOR_ERROR):
            icon = ALERT_ICON
            self.halcomp["error"] = True
        elif kind in (linuxcnc.NML_TEXT, linuxcnc.OPERATOR_TEXT):
            icon = INFO_ICON
        elif kind in (linuxcnc.NML_DISPLAY, linuxcnc.OPERATOR_DISPLAY):
            icon = INFO_ICON
        else:
            icon = ALERT_ICON
        if text == "" or text == None:
            text = _("Unknown error type and no error text given")
        self.notification.add_message(text, icon)
        if self.log:
            self._add_alarm_entry(text)

        if self._AUDIO_AVAILABLE:
            if kind == 1 or kind == 11:
                self.audio.set_sound(self.error_sound)
            else:
                self.audio.set_sound(self.alert_sound)
            self.audio.run()
#        self.halcomp["error"] = True



# =========================================================
# button handlers Start

    # toggle emergency button
    def on_tbtn_estop_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("tbtn_estop_clicked")
        if widget.get_active(): # estop is active, open circuit
            self.command.state(linuxcnc.STATE_ESTOP)
            self.command.wait_complete()
            self.stat.poll()
            if self.stat.task_state == linuxcnc.STATE_ESTOP_RESET:
                widget.set_active(False)
        else: # estop circuit is fine
            self.command.state(linuxcnc.STATE_ESTOP_RESET)
            self.command.wait_complete()
            self.stat.poll()
            if self.stat.task_state == linuxcnc.STATE_ESTOP:
                widget.set_active(True)
                self._show_error((11, _("ERROR : External ESTOP is set, could not change state!")))

    # toggle machine on / off button
    def on_tbtn_on_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("hal_tgbt_on_clicked")
        if widget.get_active():
            if self.stat.task_state == linuxcnc.STATE_ESTOP:
                widget.set_active(False)
                return
            self.command.state(linuxcnc.STATE_ON)
            self.command.wait_complete()
            self.stat.poll()
            if self.stat.task_state != linuxcnc.STATE_ON:
                widget.set_active(False)
                self._show_error((11, _("ERROR : Could not switch the machine on, is limit switch aktivated?")))
                self._update_widgets(False)
                return
            self._update_widgets(True)
        else:
            self.command.state(linuxcnc.STATE_OFF)
            self._update_widgets(False)

    # The mode buttons
    def on_rbt_manual_pressed(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_manual_pressed")
        self.command.mode(linuxcnc.MODE_MANUAL)
        self.command.wait_complete()

    def on_rbt_mdi_pressed(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_mdi_pressed")
        self.command.mode(linuxcnc.MODE_MDI)
        self.command.wait_complete()

    def on_rbt_auto_pressed(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_auto_pressed")
        self.command.mode(linuxcnc.MODE_AUTO)
        self.command.wait_complete()

    # If button exit is clicked, press emergency button bevor closing the application
    def on_btn_exit_clicked(self, widget, data = None):
        print "quit from <btn_exit>"
        if self.log: self._add_alarm_entry("btn_exit_clicked")
        self.widgets.window1.destroy()

# button handlers End
# =========================================================

# =========================================================
# hal status Start

    # use the hal_status widget to control buttons and
    # actions allowed by the user and sensitive widgets
    def on_hal_status_all_homed(self, widget):
        self.all_homed = True
        self._add_alarm_entry("all_homed")
        self.widgets.ntb_button.set_current_page(0)
        widgetlist = ["rbt_mdi", "rbt_auto", "btn_index_tool", "btn_change_tool", "btn_select_tool_by_no",
                      "btn_tool_touchoff_x", "btn_tool_touchoff_z", "btn_touch"
                     ]
        self._sensitize_widgets(widgetlist, True)

    def on_hal_status_not_all_homed(self, *args):
        self.all_homed = False
        if self.no_force_homing:
            return
        self._add_alarm_entry("not_all_homed")
        widgetlist = ["rbt_mdi", "rbt_auto", "btn_index_tool", "btn_touch", "btn_change_tool", "btn_select_tool_by_no",
                      "btn_tool_touchoff_x", "btn_tool_touchoff_z", "btn_touch"
                     ]
        self._sensitize_widgets(widgetlist, False)

    def on_hal_status_homed(self, widget, data):
        if self.log:self._add_alarm_entry(_("Axis %s are homed") % "XYZABCUVW"[int(data[0])])

    def on_hal_status_file_loaded(self, widget, filename):
        self._add_alarm_entry("file_loaded_%s" % filename)
        if len(filename) > 50:
            filename = filename[0:10] + "..." + filename[len(filename) - 39:len(filename)]
        self.widgets.lbl_program.set_text(filename)
        widgetlist = ["btn_use_current"
                     ]
        self._sensitize_widgets(widgetlist, True)

    def on_hal_status_interp_idle(self, widget):
        self._add_alarm_entry("idle")
        widgetlist = ["rbt_manual", "btn_step", "ntb_jog", "btn_from_line",
                      "tbtn_flood", "tbtn_mist", "rbt_forward", "rbt_reverse", "rbt_stop",
                      "btn_load", "btn_edit", "tbtn_optional_blocks"
                     ]
        if not self.widgets.rbt_hal_unlock.get_active():
            widgetlist.append("tbtn_setup")
        if self.all_homed or self.no_force_homing:
            widgetlist.append("rbt_mdi")
            widgetlist.append("rbt_auto")
            widgetlist.append("btn_index_tool")
            widgetlist.append("btn_change_tool")
            widgetlist.append("btn_select_tool_by_no")
            widgetlist.append("btn_tool_touchoff_x")
            widgetlist.append("btn_tool_touchoff_z")
            widgetlist.append("btn_touch")
        self._sensitize_widgets(widgetlist, True)
        for btn in self.macrobuttons:
            btn.set_sensitive(True)
        self.widgets.btn_show_kbd.set_image(self.widgets.img_keyboard)
        self.widgets.btn_run.set_sensitive(True)

    def on_hal_status_interp_run(self, widget):
        self._add_alarm_entry("run")
        widgetlist = ["rbt_manual", "rbt_mdi", "rbt_auto", "tbtn_setup", "btn_step", "btn_index_tool",
                      "btn_from_line", "btn_change_tool", "btn_select_tool_by_no",
                      "btn_load", "btn_edit", "tbtn_optional_blocks", "rbt_reverse", "rbt_stop", "rbt_forward",
                      "btn_tool_touchoff_x", "btn_tool_touchoff_z", "btn_touch"
                     ]
        # in MDI it should be possible to add more commands, even if the interpreter is running
        if self.stat.task_mode != linuxcnc.MODE_MDI:
            widgetlist.append("ntb_jog")

        self._sensitize_widgets(widgetlist, False)
        self.widgets.btn_run.set_sensitive(False)
        # the user want to run step by step
        if self.stepping == True:
            self.widgets.btn_step.set_sensitive(True)
            self.widgets.tbtn_pause.set_sensitive(False)

        self.widgets.btn_show_kbd.set_image(self.widgets.img_brake_macro)
        self.widgets.btn_show_kbd.set_property("tooltip-text", _("interrupt running macro"))

    def on_hal_status_tool_in_spindle_changed(self, object, new_tool_no):
        if self.log:self._add_alarm_entry(_("tool_in_spindle has changed to %s" % new_tool_no))
        self._update_toolinfo(new_tool_no)

    def on_hal_status_state_estop(self, widget = None):
        if self.log:self._add_alarm_entry("estop")
        self.widgets.tbtn_estop.set_active(True)
        self.widgets.tbtn_estop.set_image(self.widgets.img_emergency)
        self.widgets.tbtn_on.set_image(self.widgets.img_machine_on)
        self.widgets.tbtn_on.set_sensitive(False)
        self.widgets.chk_ignore_limits.set_sensitive(False)
        self.widgets.tbtn_on.set_active(False)
        self.command.mode(linuxcnc.MODE_MANUAL)

    def on_hal_status_state_estop_reset(self, widget = None):
        if self.log:self._add_alarm_entry("estop_reset")
        self.widgets.tbtn_estop.set_active(False)
        self.widgets.tbtn_estop.set_image(self.widgets.img_emergency_off)
        self.widgets.tbtn_on.set_image(self.widgets.img_machine_off)
        self.widgets.tbtn_on.set_sensitive(True)
        self.widgets.ntb_jog.set_sensitive(True)
        self.widgets.hbox_jog.set_sensitive(False)
        self.widgets.hbox_jog_vel.set_sensitive(False)
        self.widgets.chk_ignore_limits.set_sensitive(True)
        self._check_limits()

    def on_hal_status_state_off(self, widget):
        if self.log: self._add_alarm_entry ("State Off")
        self._add_alarm_entry("state_off")
        widgetlist = ["rbt_manual", "rbt_mdi", "rbt_auto", "btn_homing", "btn_touch", "btn_tool",
                      "hbox_jog_vel", "hbox_jog", "scl_feed", "btn_feed_100", "rbt_forward", "btn_index_tool",
                      "rbt_reverse", "rbt_stop", "tbtn_flood", "tbtn_mist", "btn_change_tool", "btn_select_tool_by_no",
                      "btn_spindle_100", "scl_max_vel", "scl_spindle",
                      "btn_tool_touchoff_x", "btn_tool_touchoff_z"
                     ]
        self._sensitize_widgets(widgetlist, False)
        if self.widgets.tbtn_on.get_active():
            self.widgets.tbtn_on.set_active(False)
        self.widgets.tbtn_on.set_image(self.widgets.img_machine_off)
        self.widgets.btn_exit.set_sensitive(True)
        self.widgets.chk_ignore_limits.set_sensitive(True)
        self.widgets.ntb_main.set_current_page(0)
        self.widgets.ntb_button.set_current_page(0)
        self.widgets.ntb_info.set_current_page(0)
        self.widgets.ntb_jog.set_current_page(0)

    def on_hal_status_state_on(self, widget):
        if self.log:self._add_alarm_entry("state_on")
        widgetlist = ["rbt_manual", "btn_homing", "btn_touch", "btn_tool",
                      "ntb_jog", "scl_feed", "btn_feed_100", "rbt_forward",
                      "rbt_reverse", "rbt_stop", "tbtn_flood", "tbtn_mist",
                      "btn_spindle_100", "scl_max_vel", "scl_spindle"
                     ]
        self._sensitize_widgets(widgetlist, True)
        if not self.widgets.tbtn_on.get_active():
            self.widgets.tbtn_on.set_active(True)
        self.widgets.tbtn_on.set_image(self.widgets.img_machine_on)
        self.widgets.btn_exit.set_sensitive(False)
        self.widgets.chk_ignore_limits.set_sensitive(False)
        if self.widgets.ntb_main.get_current_page() != 0:
            self.command.mode(linuxcnc.MODE_MANUAL)
            self.command.wait_complete()

    def on_hal_status_mode_manual(self, widget):
        if self.log: self._add_alarm_entry("Manual")
        self.widgets.rbt_manual.set_active(True)
        # setup page will be activated, if we don't leave, the pages will be reset with this call
        if self.widgets.tbtn_setup.get_active() == True:
            return
        self.widgets.ntb_main.set_current_page(0)
        self.widgets.ntb_button.set_current_page(0)
        self.widgets.ntb_info.set_current_page(0)
        self.widgets.ntb_jog.set_current_page(0)
        self._check_limits()

    def on_hal_status_mode_mdi(self, widget):
        if self.log: self._add_alarm_entry("MDI")
        # self.tool_change is set only if the tool change was commanded
        # from tooledit widget/page, so we do not want to switch the
        # screen layout to MDI, but set the manual widgets
        if self.tool_change:
            self.widgets.ntb_main.set_current_page(0)
            self.widgets.ntb_button.set_current_page(0)
            self.widgets.ntb_info.set_current_page(0)
            self.widgets.ntb_jog.set_current_page(0)
            return
        # if MDI button is not sensitive, we are not ready for MDI commands
        # so we have to aboart external commands and get back to manual mode
        # This will hapen mostly, if we are in settings mode, as we do disable the mode button
        if not self.widgets.rbt_mdi.get_sensitive():
            self.command.abort()
            self.command.mode(linuxcnc.MODE_MANUAL)
            self.command.wait_complete()
            self._show_error((13, _("It is not possible to change to MDI Mode at the moment")))
            return
        else:
            if self.widgets.chk_use_kb_on_mdi.get_active():
                self.widgets.ntb_info.set_current_page(1)
            else:
                self.widgets.ntb_info.set_current_page(0)
            self.widgets.ntb_main.set_current_page(0)
            self.widgets.ntb_button.set_current_page(1)
            self.widgets.ntb_jog.set_current_page(1)
            self.widgets.hal_mdihistory.entry.grab_focus()
            self.widgets.rbt_mdi.set_active(True)

    def on_hal_status_mode_auto(self, widget):
        if self.log: self._add_alarm_entry("Auto")
        # if Auto button is not sensitive, we are not ready for AUTO commands
        # so we have to aboart external commands and get back to manual mode
        # This will hapen mostly, if we are in settings mode, as we do disable the mode button
        if not self.widgets.rbt_auto.get_sensitive():
            self.command.abort()
            self.command.mode(linuxcnc.MODE_MANUAL)
            self.command.wait_complete()
            self._show_error((13, _("It is not possible to change to Auto Mode at the moment")))
            return
        else:
            self.widgets.ntb_main.set_current_page(0)
            self.widgets.ntb_button.set_current_page(2)
            self.widgets.ntb_info.set_current_page(0)
            self.widgets.ntb_jog.set_current_page(2)
            self.widgets.rbt_auto.set_active(True)

# hal status End
# =========================================================
    # There are some settings we can only do if the window is on the screen allready
    def on_window1_show(self, widget, data = None):

        # it is time to get the correct estop state and set the button status
        self.stat.poll()
        if self.stat.task_state == linuxcnc.STATE_ESTOP:
            self.widgets.tbtn_estop.set_active(True)
            self.widgets.tbtn_estop.set_image(self.widgets.img_emergency)
            self.widgets.tbtn_on.set_image(self.widgets.img_machine_off)
            self.widgets.tbtn_on.set_sensitive(False)
        else:
            self.widgets.tbtn_estop.set_active(False)
            self.widgets.tbtn_estop.set_image(self.widgets.img_emergency_off)
            self.widgets.tbtn_on.set_sensitive(True)

        # if a file should be loaded, we will do so
        file = self.prefs.getpref("open_file", "", str)
        if file :
            self.widgets.file_to_load_chooser.set_filename(file)
            # self.command.program_open(file)
            self.widgets.hal_action_open.load_file(file)

        # check how to start the GUI
        start_as = "rbtn_" + self.prefs.getpref("screen1", "window", str)
        self.widgets[start_as].set_active(True)
        if start_as == "rbtn_fullscreen":
            self.widgets.window1.fullscreen()
        elif start_as == "rbtn_maximized":
            self.widgets.window1.maximize()
        else:
            xpos = int(self.prefs.getpref("x_pos", 10, float))
            ypos = int(self.prefs.getpref("y_pos", 10, float))
            width = int(self.prefs.getpref("width", 979, float))
            height = int(self.prefs.getpref("height", 750, float))
            self.widgets.window1.move(xpos, ypos)
            self.widgets.window1.resize(width, height)

        # does the user want to show screen2
        self.widgets.tbtn_use_screen2.set_active(self.prefs.getpref("use_screen2", False, bool))
        self.command.mode(linuxcnc.MODE_MANUAL)
        self.command.wait_complete()

        self.initialized = True

    # kill keyboard and estop machine before closing
    def on_window1_destroy(self, widget, data = None):
        print "estopping / killing gmoccapy"
        self._kill_keyboard()
        self.command.state(linuxcnc.STATE_OFF)
        self.command.state(linuxcnc.STATE_ESTOP)
        if self.log:
            logfilename = os.path.join(CONFIGPATH, "gmoccapy.log")
            textbuffer = self.widgets.alarm_history.get_buffer()
            content = textbuffer.get_text(*textbuffer.get_bounds())
            logfile = open(logfilename, "w")
            logfile.write(content)
            logfile.close()
        gtk.main_quit()

    # What to do if a macro button has been pushed
    def _on_btn_macro_pressed(self, widget = None, data = None):
        o_codes = data.split()
        subroutines_path = self.get_ini_info.get_subroutine_path()
        if not subroutines_path:
            message = _("**** GMOCCAPY ERROR ****")
            message += _("\n**** No subroutine folder or program prefix is given in the ini file **** \n")
            message += _("**** so the corresponding file could not be found ****")
            dialogs.warning_dialog(self, _("Important Warning"), message)
            self._add_alarm_entry(message)
            return
        file = subroutines_path + "/" + o_codes[0] + ".ngc"
        if not os.path.isfile(file):
            message = _("**** GMOCCAPY ERROR ****")
            message += _("\n**** File %s of the macro could not be found ****\n" % [o_codes[0] + ".ngc"])
            message += _("**** we searched in subdirectory %s ****" % subroutines_path)
            dialogs.warning_dialog(self, _("Important Warning"), message)
            self._add_alarm_entry(message)
            return
        command = str("O<" + o_codes[0] + "> call")
        for code in o_codes[1:]:
            parameter = dialogs.entry_dialog(self, data = None, header = _("Enter value:"),
                                          label = _("Set parameter %s to:") % code, integer = False)
            if parameter == "ERROR":
                print(_("conversion error"))
                self._add_alarm_entry(_("Conversion error because off wrong entry for macro %s") % o_codes[0])
                dialogs.warning_dialog(self, _("Conversion error !"),
                                      _("Please enter only numerical values\nValues have not been applied"))
                return
            elif parameter == "CANCEL":
                self._add_alarm_entry(_("entry for macro %s has been canceled") % o_codes[0])
                return
            else:
                self._add_alarm_entry(_("macro {0} , parameter {1} set to {2:f}").format(o_codes[0], code, parameter))
            command = command + " [" + str(parameter) + "] "
# TODO: Should not only clear the plot, but also the loaded programm?
        # self.command.program_open("")
        # self.command.reset_interpreter()
        self.widgets.gremlin.clear_live_plotter()
# TODO: End
        self.command.mdi(command)
        for btn in self.macrobuttons:
            btn.set_sensitive(False)
        # we change the widget_image and use the button to interupt running macros
        self.widgets.btn_show_kbd.set_image(self.widgets.img_brake_macro)
        self.widgets.btn_show_kbd.set_property("tooltip-text", _("interrupt running macro"))
        self.widgets.ntb_info.set_current_page(0)

# helpers functions start

    def _update_widgets(self, state):
        widgetlist = ["rbt_manual", "btn_homing", "btn_touch", "btn_tool",
                      "hbox_jog_vel", "hbox_jog", "scl_feed", "btn_feed_100", "rbt_forward", "btn_index_tool",
                      "rbt_reverse", "rbt_stop", "tbtn_flood", "tbtn_mist", "btn_change_tool", "btn_select_tool_by_no",
                      "btn_spindle_100", "scl_max_vel", "scl_spindle",
                      "btn_tool_touchoff_x", "btn_tool_touchoff_z"
                     ]
        self._sensitize_widgets(widgetlist, state)

    def on_key_event(self, widget, event, signal):

        # get the keyname
        keyname = gtk.gdk.keyval_name(event.keyval)
        # print("pressed key = ",keyname

        # estop with F1 shold work every time
        # so should also escape aboart actions
        if keyname == "F1": # will estop the machine, but not reset estop!
            self.command.state(linuxcnc.STATE_ESTOP)
            return True
        if keyname == "Escape":
            self.command.abort()
            return True

        # This will avoid excecuting the key press event several times caused by keyboard auto repeat
        if self.last_key_event[0] == keyname and self.last_key_event[1] == signal:
            return True

        try:
            if keyname == "F2" and signal:
                # only turn on if no estop!
                if self.widgets.tbtn_estop.get_active():
                    return True
                self.widgets.tbtn_on.emit("clicked")
                return True
        except:
            pass

        if keyname == "space" and signal:
            if event.state & gtk.gdk.CONTROL_MASK: # only do it when control is hold down
                self.notification.del_message(-1)
                self.widgets.window1.grab_focus()
                return

        if keyname == "Super_L" and signal: # Left Windows
            self.notification.del_last()
            self.widgets.window1.grab_focus()
            return

        # if the user do not want to use keyboard shortcuts, we leave here
        # in this case we do not return true, otherwise entering code in MDI history
        # and the integrated editor will not work
        if not self.widgets.chk_use_kb_shortcuts.get_active():
            print("Settings say: do not use keyboard shortcuts, aboart")
            return

        # Only in manual mode jogging with keyboard is allowed
        # in this case we do not return true, otherwise entering code in MDI history
        # and the integrated editor will not work
        # we also check if we are in settings or terminal or alarm page
        if self.stat.task_mode != linuxcnc.MODE_MANUAL or not self.widgets.ntb_main.get_current_page() == 0:
            return

        # offset page is active, so keys must go through
        if self.widgets.ntb_preview.get_current_page() == 1:
            return

        # tooledit page is active, so keys must go through
        if self.widgets.ntb_preview.get_current_page() == 2:
            return

        # take care of differnt key handling for lathe operation
        if self.lathe_mode:
            if keyname == "Page_Up" or keyname == "Page_Down":
                return

        if event.state & gtk.gdk.SHIFT_MASK: # SHIFT is hold down, fast jogging active
            fast = True
        else:
            fast = False

        if keyname == "Up":
            if self.lathe_mode:
                if self.backtool_lathe:
                    widget = self.widgets.btn_x_plus
                else:
                    widget = self.widgets.btn_x_minus
            else:
                widget = self.widgets.btn_y_plus
            if signal:
                self.on_btn_jog_pressed(widget, fast)
            else:
                self.on_btn_jog_released(widget)
        elif keyname == "Down":
            if self.lathe_mode:
                if self.backtool_lathe:
                    widget = self.widgets.btn_x_minus
                else:
                    widget = self.widgets.btn_x_plus
            else:
                widget = self.widgets.btn_y_minus
            if signal:
                self.on_btn_jog_pressed(widget, fast)
            else:
                self.on_btn_jog_released(widget)
        elif keyname == "Left":
            if self.lathe_mode:
                widget = self.widgets.btn_z_minus
            else:
                widget = self.widgets.btn_x_minus
            if signal:
                self.on_btn_jog_pressed(widget, fast)
            else:
                self.on_btn_jog_released(widget)
        elif keyname == "Right":
            if self.lathe_mode:
                widget = self.widgets.btn_z_plus
            else:
                widget = self.widgets.btn_x_plus
            if signal:
                self.on_btn_jog_pressed(widget, fast)
            else:
                self.on_btn_jog_released(widget)
        elif keyname == "Page_Up":
            widget = self.widgets.btn_z_plus
            if signal:
                self.on_btn_jog_pressed(widget, fast)
            else:
                self.on_btn_jog_released(widget)
        elif keyname == "Page_Down":
            widget = self.widgets.btn_z_minus
            if signal:
                self.on_btn_jog_pressed(widget, fast)
            else:
                self.on_btn_jog_released(widget)
        else:
            print("This key has not been implemented yet")
            print "Key %s (%d) was pressed" % (keyname, event.keyval), signal, self.last_key_event
        self.last_key_event = keyname, signal
        return True

    # Notification stuff.
    def init_notification(self):
        start_as = "rbtn_" + self.prefs.getpref("screen1", "window", str)
        xpos, ypos = self.widgets.window1.window.get_origin()
        self.notification.set_property('x_pos' , self.widgets.adj_x_pos_popup.get_value())
        self.notification.set_property('y_pos' , self.widgets.adj_y_pos_popup.get_value())
        self.notification.set_property('message_width' , self.widgets.adj_width_popup.get_value())
        if int(self.widgets.adj_max_messages.get_value()) != 0:
            self.notification.set_property('max_messages', self.widgets.adj_max_messages.get_value())
        self.notification.set_property('use_frames', self.widgets.chk_use_frames.get_active())
        self.notification.set_property('font', self.widgets.fontbutton_popup.get_font_name())
# TODO:
        # this ones are not finished yet in notifications, we do add them at
        # a later development state, just to show they are there
        self.notification.set_property('icon_size' , 48)
        self.notification.set_property('top_to_bottom', True)
# TODO: End

    # This is the jogging part
    def on_increment_changed(self, widget = None, data = None):
        if self.log: self._add_alarm_entry("increment_changed %s" % data)
        if data == 0:
            self.distance = 0
        else:
            self.distance = self._parse_increment(data)
        self.halcomp["jog-increment"] = self.distance

    def _from_internal_linear_unit(self, v, unit = None):
        if unit is None:
            unit = self.stat.linear_units
        lu = (unit or 1) * 25.4
        return v * lu

    def _parse_increment(self, jogincr):
        if jogincr.endswith("mm"):
            scale = self._from_internal_linear_unit(1 / 25.4)
        elif jogincr.endswith("cm"):
            scale = self._from_internal_linear_unit(10 / 25.4)
        elif jogincr.endswith("um"):
            scale = self._from_internal_linear_unit(.001 / 25.4)
        elif jogincr.endswith("in") or jogincr.endswith("inch"):
            scale = self._from_internal_linear_unit(1.)
        elif jogincr.endswith("mil"):
            scale = self._from_internal_linear_unit(.001)
        else:
            scale = 1
        jogincr = jogincr.rstrip(" inchmuil")
        if "/" in jogincr:
            p, q = jogincr.split("/")
            jogincr = float(p) / float(q)
        else:
            jogincr = float(jogincr)
        return jogincr * scale

    def _replace_list_item(self, int_tab, old_value, new_value):
        list = self.h_tabs[int_tab]
        self.h_tabs[int_tab] = []
        for item in list:
            if item[1] == old_value:
                new_tupple = (item[0], new_value)
                item = new_tupple
                print(_("**** GMOCCAPY INFO ****"))
                print(_("**** replaced {0} to {1} ****".format(old_value, new_value)))
            self.h_tabs[int_tab].append(item)

    # check if macros are in the INI file and add them to MDI Button List
    def _add_macro_button(self):
        macros = self.get_ini_info.get_macros()
        num_macros = len(macros)
        if num_macros > 9:
            message = _("**** GMOCCAPY INFO ****")
            message += _("\n**** found more than 9 macros, only the first 9 will be used ****")
            self._add_alarm_entry(message)
            print(message)
            num_macros = 9
        for increment in range(0, num_macros):
            name = macros[increment]
            # shorten the name if it is to long
            if len(name) > 11:
                lbl = name[0:10]
            else:
                lbl = macros[increment]
            btn = gtk.Button(lbl, None, False)
            btn.connect("pressed", self._on_btn_macro_pressed, name)
            btn.position = increment
            # we add the button to a list to be able later to see what makro to excecute
            self.macrobuttons.append(btn)
            self.widgets.hbtb_MDI.pack_start(btn, True, True, 0)
            btn.show()
        # if there is still place, we fill it with empty labels, to be sure the button will not be on differnt
        # places if the amount of macros change.
        if num_macros < 9:
            for label_space in range(num_macros, 9):
                lbl = "lbl_sp_%s" % label_space
                lbl = gtk.Label(lbl)
                lbl.position = label_space
                lbl.set_text("")
                self.widgets.hbtb_MDI.pack_start(lbl, True, True, 0)
                lbl.show()
        self.widgets.hbtb_MDI.non_homogeneous = False

    def _add_alarm_entry(self, message):
        try:
            textbuffer = self.widgets.alarm_history.get_buffer()
            textbuffer.insert_at_cursor(strftime("%a, %d %b %Y %H:%M:%S     -", localtime()) + message + "\n")
        except:
            self.show_try_errors()

    def show_try_errors(self):
        exc_type, exc_value, exc_traceback = sys.exc_info()
        formatted_lines = traceback.format_exc().splitlines()
        print(_("**** GMOCCAPY ERROR ****"))
        print(_("**** %s ****" % formatted_lines[0]))
        traceback.print_tb(exc_traceback, limit = 1, file = sys.stdout)
        print (formatted_lines[-1])

    def _sensitize_widgets(self, widgetlist, value):
        for name in widgetlist:
            try:
                self.widgets[name].set_sensitive(value)
            except Exception, e:
                print (_("**** GMOCCAPY ERROR ****"))
                print _("**** No widget named: %s to sensitize ****" % name)
                traceback.print_exc()

    def _update_active_gcodes(self):
        # active G codes
        active_codes = []
        temp = []
        for code in sorted(self.stat.gcodes[1:]):
            if code == -1:
                continue
            if code % 10 == 0:
                temp.append("%d" % (code / 10))
            else:
                temp.append("%d.%d" % (code / 10, code % 10))
        for num, code in enumerate(temp):
            if num == 8:
                active_codes.append("\n")
            active_codes.append("G" + code)
        self.active_gcodes = active_codes
        self.gcodes = self.stat.gcodes
        self.widgets.active_gcodes_label.set_label(" ".join(self.active_gcodes))

    def _update_active_mcodes(self):
        # M codes
        active_codes = []
        temp = []
        for code in sorted(self.stat.mcodes[1:]):
            if code == -1:
                continue
            temp.append("%d" % code)
        for code in (temp):
            active_codes.append("M" + code)
        self.active_mcodes = active_codes
        self.mcodes = self.stat.mcodes
        self.widgets.active_mcodes_label.set_label(" ".join(self.active_mcodes))

    # Update the velocity labels
    def _update_vel(self):
        # self.stat.program_units will return 1 for inch, 2 for mm and 3 for cm
        real_feed = float(self.stat.settings[1] * self.stat.feedrate)
        if self.stat.program_units != 1:
            self.widgets.lbl_current_vel.set_text("%d" % (self.stat.current_vel * 60.0 * self.faktor))
            if "G95" in self.active_gcodes:
                feed_str = "%d" % self.stat.settings[1]
                real_feed_str = "F  %.2f" % real_feed
            else:
                feed_str = "%d" % self.stat.settings[1]
                real_feed_str = "F  %.d" % real_feed
        else:
            self.widgets.lbl_current_vel.set_text("%.3f" % (self.stat.current_vel * 60.0 * self.faktor))
            if "G95" in self.active_gcodes:
                feed_str = "%.4f" % self.stat.settings[1]
                real_feed_str = "F %.4f" % real_feed
            else:
                feed_str = "%.3f" % self.stat.settings[1]
                real_feed_str = "F %.3f" % real_feed

        # converting 0.0 to string brings nothing, so the string is empty
        # happens only on start up
        if not real_feed:
            real_feed_str = "F  0"

        self.widgets.lbl_active_feed.set_label(feed_str)
        self.widgets.lbl_feed_act.set_text(real_feed_str)

        # set the speed label in active code frame
        self.widgets.active_speed_label.set_label("%.0f" % self.stat.settings[2])

    def _update_coolant(self):
        if self.stat.flood:
            if not self.widgets.tbtn_flood.get_active():
                self.widgets.tbtn_flood.set_active(True)
                self.widgets.tbtn_flood.set_image(self.widgets.img_coolant_on)
        else:
            if self.widgets.tbtn_flood.get_active():
                self.widgets.tbtn_flood.set_active(False)
                self.widgets.tbtn_flood.set_image(self.widgets.img_coolant_off)
        if self.stat.mist:
            if not self.widgets.tbtn_mist.get_active():
                self.widgets.tbtn_mist.set_active(True)
                self.widgets.tbtn_mist.set_image(self.widgets.img_mist_on)
        else:
            if self.widgets.tbtn_mist.get_active():
                self.widgets.tbtn_mist.set_active(False)
                self.widgets.tbtn_mist.set_image(self.widgets.img_mist_off)

    def _update_slider(self, widgetlist):
        # update scales and sliders
        for widget in widgetlist:
            value = self.widgets[widget].get_value()
            max = self.widgets[widget].upper
            min = self.widgets[widget].lower
            self.widgets[widget].lower = min * self.faktor
            self.widgets[widget].upper = max * self.faktor
            self.widgets[widget].set_value(value * self.faktor)
        self.scale_jog_vel = self.scale_jog_vel * self.faktor
        self.scale_max_vel = self.scale_max_vel * self.faktor
        self.on_adj_max_vel_value_changed(self.widgets.adj_max_vel)

    def _change_dro_color(self, property, color):
        for axis in self.axis_list:
            if axis == self.axisletter_four:
                axis = 4
            self.widgets["Combi_DRO_%s" % axis].set_property(property, color)
        if self.lathe_mode:
            self.widgets.Combi_DRO_y.set_property(property, color)
            # check if G7 or G8 is active
            # this is set on purpose wrong, because we want the periodic
            # to update the state correctly
            if "G7" in self.active_gcodes:
                self.diameter_mode = False
            else:
                self.diameter_mode = True

    def _update_toolinfo(self, tool):
        toolinfo = self.widgets.tooledit1.get_toolinfo(tool)
        if toolinfo:
            # Doku
            # toolinfo[0] = cell toggle
            # toolinfo[1] = tool number
            # toolinfo[2] = pocket number
            # toolinfo[3] = X offset
            # toolinfo[4] = Y offset
            # toolinfo[5] = Z offset
            # toolinfo[6] = A offset
            # toolinfo[7] = B offset
            # toolinfo[8] = C offset
            # toolinfo[9] = U offset
            # toolinfo[10] = V offset
            # toolinfo[11] = W offset
            # toolinfo[12] = tool diameter
            # toolinfo[13] = frontangle
            # toolinfo[14] = backangle
            # toolinfo[15] = tool orientation
            # toolinfo[16] = tool info
            self.widgets.lbl_tool_no.set_text(str(toolinfo[1]))
            self.widgets.lbl_tool_dia.set_text(toolinfo[12])
            self.widgets.lbl_tool_name.set_text(toolinfo[16])

        # we do not allow touch off with no tool mounted, so we set the
        # coresponding widgets unsensitive and set the description acordingly
        if tool == 0:
            self.widgets.lbl_tool_no.set_text("0")
            self.widgets.lbl_tool_dia.set_text("0")
            self.widgets.lbl_tool_name.set_text(_("No tool description available"))
            self.widgets.btn_tool_touchoff_x.set_sensitive(False)
            self.widgets.btn_tool_touchoff_z.set_sensitive(False)
        else:
            self.widgets.btn_tool_touchoff_x.set_sensitive(True)
            self.widgets.btn_tool_touchoff_z.set_sensitive(True)

        if "G43" in self.active_gcodes and self.stat.task_mode != linuxcnc.MODE_AUTO:
            self.command.mode(linuxcnc.MODE_MDI)
            self.command.wait_complete()
            self.command.mdi("G43")
            self.command.wait_complete()

        if self.tool_change:
            self.tool_change = False
            self.command.mode(linuxcnc.MODE_MANUAL)
            self.command.wait_complete()

# helpers functions end

    def on_Combi_DRO_clicked(self, widget, joint_number, order):
        for axis in self.axis_list:
            if axis == self.axisletter_four:
                axis = 4
            self.widgets["Combi_DRO_%s" % axis].set_order(order)
        if self.lathe_mode:
            self.widgets.Combi_DRO_y.set_order(order)
        self._offset_changed(None, None)
# from here only needed, if the DRO button will remain in gmoccapy
        if order[0] == "Abs" and self.widgets.tbtn_rel.get_label() != "Abs":
            self.widgets.tbtn_rel.set_active(False)
        if order[0] == "Rel" and self.widgets.tbtn_rel.get_label() != self.widgets.Combi_DRO_x.system:
            self.widgets.tbtn_rel.set_active(True)
        if order[0] == "DTG":
            self.widgets.tbtn_dtg.set_active(True)
        else:
            self.widgets.tbtn_dtg.set_active(False)
# to here only needed, if the DRO button will remain in gmoccapy

    def _offset_changed(self, pin, tooloffset):
        if self.widgets.Combi_DRO_x.machine_units == _MM:
            self.widgets.lbl_tool_offset_z.set_text("%.3f" % self.halcomp["tooloffset-z"])
            self.widgets.lbl_tool_offset_x.set_text("%.3f" % self.halcomp["tooloffset-x"])
        else:
            self.widgets.lbl_tool_offset_z.set_text("%.4f" % self.halcomp["tooloffset-z"])
            self.widgets.lbl_tool_offset_x.set_text("%.4f" % self.halcomp["tooloffset-x"])

    def on_offsetpage1_selection_changed(self, widget, system, name):
        if self.log: self._add_alarm_entry("Selection Changed to %s %s" % (system, name))
        if system not in self.system_list[1: ] or self.widgets.tbtn_edit_offsets.get_active():
            self.widgets.btn_set_selected.set_sensitive(False)
        else:
            self.widgets.btn_set_selected.set_sensitive(True)

# from here only needed, if the DRO button will remain in gmoccapy
    def on_Combi_DRO_system_changed(self, widget, system):
        if self.widgets.tbtn_rel.get_active():
            self.widgets.tbtn_rel.set_label(system)
        else:
            self.widgets.tbtn_rel.set_label("Abs")

    def on_Combi_DRO_units_changed(self, widget, metric_units):
        # if the user do not wish to use auto units, we leave here
        if not self.widgets.chk_auto_units.get_active():
            return

        # set gremlin_units
        self.widgets.gremlin.set_property("metric_units", metric_units)

        widgetlist = ["adj_jog_vel", "adj_max_vel"]

        # self.stat.linear_units will return 1.0 for metric and 1/25,4 for imperial
        # display units not equal machine units
        if metric_units != int(self.stat.linear_units):
            # machine units = metric
            if self.stat.linear_units == _MM:
                self.faktor = (1.0 / 25.4)
            # machine units = imperial
            else:
                self.faktor = 25.4
            self._update_slider(widgetlist)
        else:
            # display units equal machine units would be factor = 1,
            # but if factor not equal 1.0 than we have to reconvert from previous first
            if self.faktor != 1.0:
                self.faktor = 1 / self.faktor
                self._update_slider(widgetlist)
                self.faktor = 1.0
                self._update_slider(widgetlist)

        if metric_units:
            self.widgets.scl_max_vel.set_digits(0)
            self.widgets.scl_jog_vel.set_digits(0)
        else:
            self.widgets.scl_max_vel.set_digits(3)
            self.widgets.scl_jog_vel.set_digits(3)

    def on_tbtn_rel_toggled(self, widget, data = None):
        if self.widgets.tbtn_dtg.get_active():
            self.widgets.tbtn_dtg.set_active(False)
        if widget.get_active():
            widget.set_label(self.widgets.Combi_DRO_x.system)
            order = ["Rel", "Abs", "DTG"]
        else:
            widget.set_label("Abs")
            order = ["Abs", "DTG", "Rel"]
        self.on_Combi_DRO_clicked(None, None, order)

    def on_tbtn_dtg_toggled(self, widget, data = None):
        if widget.get_active():
            widget.set_label("GTD")
            order = ["DTG", "Rel", "Abs"]
        else:
            widget.set_label("DTG")
            if self.widgets.tbtn_rel.get_active():
                order = ["Rel", "Abs", "DTG"]
            else:
                order = ["Abs", "DTG", "Rel"]
        self.on_Combi_DRO_clicked(None, None, order)

    def on_tbtn_units_toggled(self, widget, data = None):
        if widget.get_active():
            widget.set_label("inch")
            metric_units = False
        else:
            widget.set_label("mm")
            metric_units = True
        for axis in self.axis_list:
            if axis == self.axisletter_four:
                axis = 4
            self.widgets["Combi_DRO_%s" % axis].set_to_inch(not metric_units)
        if self.lathe_mode:
            self.widgets.Combi_DRO_y.set_to_inch(not metric_units)
        # set gremlin_units
        self.widgets.gremlin.set_property("metric_units", metric_units)

    def on_chk_auto_units_toggled(self, widget, data = None):
        for axis in self.axis_list:
            if axis == self.axisletter_four:
                axis = 4
            self.widgets["Combi_DRO_%s" % axis].set_auto_units(self.widgets.chk_auto_units.get_active())
        if self.lathe_mode:
            self.widgets.Combi_DRO_y.set_auto_units(self.widgets.chk_auto_units.get_active())
        self.prefs.putpref("use_auto_units", self.widgets.chk_auto_units.get_active(), bool)

    def on_chk_show_dro_btn_toggled(self, widget, data = None):
        if self.widgets.chk_show_dro_btn.get_active():
            self.widgets.tbl_dro_button.show()
            self.widgets.chk_auto_units.set_active(False)
            self.widgets.chk_auto_units.set_sensitive(False)
        else:
            self.widgets.tbl_dro_button.hide()
            self.widgets.chk_auto_units.set_active(True)
            self.widgets.chk_auto_units.set_sensitive(True)
        self.prefs.putpref("show_dro_btn", self.widgets.chk_show_dro_btn.get_active(), bool)
# to here only needed, if the DRO button will remain in gmoccapy

    def on_adj_x_pos_popup_value_changed(self, widget, data = None):
        if not self.initialized:
            return
        self.prefs.putpref("x_pos_popup", widget.get_value(), float)
        self.init_notification()

    def on_adj_y_pos_popup_value_changed(self, widget, data = None):
        if not self.initialized:
            return
        self.prefs.putpref("y_pos_popup", widget.get_value(), float)
        self.init_notification()

    def on_adj_width_popup_value_changed(self, widget, data = None):
        if not self.initialized:
            return
        self.prefs.putpref("width_popup", widget.get_value(), float)
        self.init_notification()

    def on_adj_max_messages_value_changed(self, widget, data = None):
        if not self.initialized:
            return
        self.prefs.putpref("max_messages", widget.get_value(), float)
        self.init_notification()

    def on_chk_use_frames_toggled(self, widget, data = None):
        if not self.initialized:
            return
        self.prefs.putpref("use_frames", widget.get_active(), bool)
        self.init_notification()

    def on_fontbutton_popup_font_set(self, font):
        self.prefs.putpref("message_font", self.widgets.fontbutton_popup.get_font_name() , str)
        self.init_notification()

    def on_btn_launch_test_message_pressed(self, widget = None, data = None):
        index = len(self.notification.messages)
        text = _("Halo, welcome to the test message %d") % index
        self._show_error((13, text))

    def on_btn_jog_pressed(self, widget, data = None):
        # only in manual mode we will allow jogging the axis at this development state
        if not self.stat.task_mode == linuxcnc.MODE_MANUAL:
            return

        axisletter = widget.get_label()[0]
        if not axisletter.lower() in "xyzabcuvw":
            print ("unknown axis %s" % axisletter)
            return

        # get the axisnumber
        axisnumber = "xyzabcuvws".index(axisletter.lower())

        # if data = True, then the user pressed SHIFT for Jogging and
        # want's to jog at full speed
        if data:
            value = self.widgets.adj_max_vel.get_value() / 60
        else:
            value = self.widgets.adj_jog_vel.get_value() / 60

        velocity = value * (1 / self.faktor)


        dir = widget.get_label()[1]
        if dir == "+":
            direction = 1
        else:
            direction = -1

        self._add_alarm_entry("btn_jog_%i_%i" % (axisnumber, direction))

        if self.distance <> 0: # incremental jogging
            self.command.jog(linuxcnc.JOG_INCREMENT, axisnumber, direction * velocity, self.distance)
        else: # continuous jogging
            self.command.jog(linuxcnc.JOG_CONTINUOUS, axisnumber, direction * velocity)

    def on_btn_jog_released(self, widget, data = None):
        axisletter = widget.get_label()[0]
        if not axisletter.lower() in "xyzabcuvw":
            print ("unknown axis %s" % axisletter)
            return

        axis = "xyzabcuvw".index(axisletter.lower())

        if self.distance <> 0:
            pass
        else:
            self.command.jog(linuxcnc.JOG_STOP, axis)

    # use the current loaded file to be loaded on start up
    def on_btn_use_current_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("use_current_clicked %s" % self.stat.file)
        if self.stat.file:
            self.widgets.file_to_load_chooser.set_filename(self.stat.file)
            self.prefs.putpref("open_file", self.stat.file, str)

    # Clear the status to load a file on start up, so there will not be loaded a programm
    # on the next start of the GUI
    def on_btn_none_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("button none clicked %s")
        self.widgets.file_to_load_chooser.set_filename(" ")
        self.prefs.putpref("open_file", " ", str)

    def on_ntb_main_switch_page(self, widget, page, page_num, data = None):
        if self.log:
            message = "ntb_main_page changed to %s" % self.widgets.ntb_main.get_current_page()
            self._add_alarm_entry(message)
        if self.widgets.tbtn_setup.get_active():
            if page_num != 1L: # setup page is active,
                 self.widgets.tbtn_setup.set_active(False)

    def on_tbtn_setup_toggled(self, widget, data = None):
        # first we set to manual mode, as we do not allow changing settings in other modes
        # otherwise external halui commands could start a program while we are in settings
        self.command.mode(linuxcnc.MODE_MANUAL)
        self.command.wait_complete()

        if widget.get_active():
            # deactivate the mode buttons, so changing modes is not possible while we are in settings mode
            self.widgets.rbt_manual.set_sensitive(False)
            self.widgets.rbt_mdi.set_sensitive(False)
            self.widgets.rbt_auto.set_sensitive(False)
            if self.log: self._add_alarm_entry("tbtn_setup_pressed")
            code = False
            # here the user don"t want an unlock code
            if self.widgets.rbt_no_unlock.get_active():
                code = True
            # if hal pin is true, we are allowed to enter settings, this may be
            # realized using a key switch
            if self.widgets.rbt_hal_unlock.get_active() and self.halcomp["unlock-settings"]:
                code = True
            # else we ask for the code using the system.dialog
            if self.widgets.rbt_use_unlock.get_active():
                if dialogs.system_dialog(self):
                    code = True
            # Lets see if the user has the right to enter settings
            if code:
                self.widgets.ntb_main.set_current_page(1)
                self.widgets.ntb_setup.set_current_page(1)
                self.widgets.ntb_button.set_current_page(5)
            else:
                if self.widgets.rbt_hal_unlock.get_active():
                    message = _("Hal Pin is low, Access denied")
                else:
                    message = _("wrong code entered, Access denied")
                dialogs.warning_dialog(self, _("Just to warn you"), message)
                self._add_alarm_entry(message)
                self.widgets.tbtn_setup.set_active(False)
        else:
            # check witch button should be sensitive, depending on the state of the machine
            if self.stat.task_state == linuxcnc.STATE_ESTOP:
                # estoped no mode availible
                self.widgets.rbt_manual.set_sensitive(False)
                self.widgets.rbt_mdi.set_sensitive(False)
                self.widgets.rbt_auto.set_sensitive(False)
            if (self.stat.task_state == linuxcnc.STATE_ON) and not self.all_homed:
                # machine on, but not homed, only manual allowed
                self.widgets.rbt_manual.set_sensitive(True)
                self.widgets.rbt_mdi.set_sensitive(False)
                self.widgets.rbt_auto.set_sensitive(False)
            if (self.stat.task_state == linuxcnc.STATE_ON) and (self.all_homed or self.no_force_homing):
                # all OK, make all modes availible
                self.widgets.rbt_manual.set_sensitive(True)
                self.widgets.rbt_mdi.set_sensitive(True)
                self.widgets.rbt_auto.set_sensitive(True)
            # this is needed here, because we do not
            # change mode, so on_hal_status_manual will not be called
            self.widgets.ntb_main.set_current_page(0)
            self.widgets.ntb_button.set_current_page(0)
            self.widgets.ntb_info.set_current_page(0)
            self.widgets.ntb_jog.set_current_page(0)

    # Show or hide the user tabs
    def on_tbtn_user_tabs_toggled(self, widget, data = None):
        if widget.get_active():
            self.widgets.ntb_main.set_current_page(2)
            self.widgets.tbtn_fullsize_preview.set_sensitive(False)
        else:
            self.widgets.ntb_main.set_current_page(0)
            self.widgets.tbtn_fullsize_preview.set_sensitive(True)

    # The homing functions
    def on_btn_homing_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_homing_clicked")
        self.widgets.ntb_button.set_current_page(3)

    def on_btn_home_all_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("button ref all clicked")
        # home -1 means all
        self.command.home(-1)

    def on_btn_unhome_all_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("button unhome all clicked")
        self.all_homed = False
        # -1 for all
        self.command.unhome(-1)

    def on_btn_home_selected_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("button home selected clicked")
        if widget == self.widgets.btn_home_x:
            axis = 0
        elif widget == self.widgets.btn_home_y:
            axis = 1
        elif widget == self.widgets.btn_home_z:
            axis = 2
        elif widget == self.widgets.btn_home_4:
            axis = "xyzabcuvw".index(self.axisletter_four)
        self.command.home(axis)

    def _check_limits(self):
        for axis in self.axis_list:
            axisnumber = "xyzabcuvw".index(axis)
            if self.stat.limit[axisnumber] != 0:
                return True
        if self.widgets.chk_ignore_limits.get_active():
            self.widgets.chk_ignore_limits.set_active(False)
        return False

    def on_chk_ignore_limits_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("chk_ignore_limits_toggled %s" % widget.get_active())
        if self.widgets.chk_ignore_limits.get_active():
            if not self._check_limits():
                self._show_error((11, _("ERROR : No limit switch is active, ignore limits will not be set.")))
                return
            self.command.override_limits()

    def on_tbtn_fullsize_preview_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("Fullsize Preview set to %s" % widget.get_active())
        if widget.get_active():
            self.widgets.box_info.hide()
            self.widgets.vbx_jog.hide()
            self.widgets.gremlin.set_property("metric_units", self.widgets.Combi_DRO_x.metric_units)
            self.widgets.gremlin.set_property("enable_dro", True)
            if self.lathe_mode:
                self.widgets.gremlin.set_property("show_lathe_radius", not self.diameter_mode)
        else:
            self.widgets.box_info.show()
            self.widgets.vbx_jog.show()
            if not self.widgets.chk_show_dro.get_active():
                self.widgets.gremlin.set_property("enable_dro", False)

    # this are hal-tools through gsreen function
    def on_btn_show_hal_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_show_hal_clicked")
        p = os.popen("tclsh %s/bin/halshow.tcl &" % TCLPATH)

    def on_btn_calibration_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_calibration_clicked")
        p = os.popen("tclsh %s/bin/emccalib.tcl -- -ini %s > /dev/null &" % (TCLPATH, sys.argv[2]), "w")

    def on_btn_hal_meter_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_hal_meter_clicked")
        p = os.popen("halmeter &")

    def on_btn_status_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("hal_btn_status_clicked")
        p = os.popen("linuxcnctop  > /dev/null &", "w")

    def on_btn_hal_scope_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("hal_btn_hal_scope_clicked")
        p = os.popen("halscope  > /dev/null &", "w")

    def on_btn_classicladder_clicked(self, widget, data = None):
        if  hal.component_exists("classicladder_rt"):
            p = os.popen("classicladder  &", "w")
        else:
            dialogs.warning_dialog(self, _("INFO:"),
                                  _("Classicladder real-time component not detected"))
            self._add_alarm_entry(_("ladder not available - is the real-time component loaded?"))

#-----------------------------------------------------------
# spindle stuff
#-----------------------------------------------------------
    def _update_spindle_btn(self):
        if self.stat.spindle_direction > 0:
            self.widgets.rbt_forward.set_active(True)
        elif self.stat.spindle_direction < 0:
            self.widgets.rbt_reverse.set_active(True)
        elif not self.widgets.rbt_stop.get_active():
            self.widgets.rbt_stop.set_active(True)
        # this is needed, because otherwise a command S0 would not set active btn_stop
        if not abs(self.stat.spindle_speed):
            self.widgets.rbt_stop.set_active(True)
            return

    def on_rbt_forward_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_forward_clicked")
        if widget.get_active():
            widget.set_image(self.widgets.img_forward_on)
            self._set_spindle("forward")
        else:
            self.widgets.rbt_forward.set_image(self.widgets.img_forward)

    def on_rbt_reverse_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_reverse_clicked")
        if widget.get_active():
            widget.set_image(self.widgets.img_reverse_on)
            self._set_spindle("reverse")
        else:
            widget.set_image(self.widgets.img_reverse)

    def on_rbt_stop_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_stop_clicked")
        if widget.get_active():
            widget.set_image(self.widgets.img_stop_on)
            self._set_spindle("stop")
        else:
            self.widgets.rbt_stop.set_image(self.widgets.img_sstop)

    def _set_spindle(self, command):
        # if we are in estop state, we will have to leave here, otherwise
        # we get an error, that switching spindle off is not allowed with estop
        if self.stat.task_state == linuxcnc.STATE_ESTOP:
            return
        rpm = self._check_spindle_range()
        # as the commanded value will be multiplied with speed override,
        # we take care of that
        rpm_out = rpm / self.stat.spindlerate
        self.widgets.lbl_spindle_act.set_label("S %s" % int(rpm))
        if self.log: self._add_alarm_entry("Spindle set to %i rpm, mode is %s" % (rpm, self.stat.task_mode))

        # if we do not check this, we will get an error in auto mode
        if self.stat.task_mode == linuxcnc.MODE_AUTO:
            if self.stat.interp_state == linuxcnc.INTERP_READING or self.stat.interp_state == linuxcnc.INTERP_WAITING:
                return
        if command == "stop":
            self.command.spindle(0)
            self.widgets.lbl_spindle_act.set_label("S 0")
        if command == "forward":
            self.command.spindle(1, rpm_out)
        elif command == "reverse":
            self.command.spindle(-1, rpm_out)
        else:
            self._add_alarm_entry(_("Something went wrong, we have an unknown widget"))

    def _check_spindle_range(self):
        rpm = self.stat.settings[2]
        if rpm == 0:
            rpm = abs(self.spindle_start_rpm)

        spindle_override = self.widgets.adj_spindle.get_value() / 100
        real_spindle_speed = rpm * spindle_override

        if real_spindle_speed > self.max_spindle_rev:
            real_spindle_speed = self.max_spindle_rev
        elif real_spindle_speed < self.min_spindle_rev:
            real_spindle_speed = self.min_spindle_rev
        return real_spindle_speed

    def on_btn_spindle_100_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("spindle override has been reseted to 100 %")
        self.widgets.adj_spindle.set_value(100)

    def on_adj_spindle_value_changed(self, widget, data = None):
        if not self.initialized:
            return
        # this is in a try except, because on initializing the window the values are still zero
        # so we would get an division / zero error
        real_spindle_speed = 0
        try:
            if not abs(self.stat.settings[2]):
                if self.widgets.rbt_forward.get_active() or self.widgets.rbt_reverse.get_active():
                    speed = self.stat.spindle_speed
                else:
                    speed = 0
            else:
                speed = abs(self.stat.settings[2])
            spindle_override = widget.get_value() / 100
            real_spindle_speed = speed * spindle_override
            if real_spindle_speed > self.max_spindle_rev:
                value_to_set = widget.get_value() / (real_spindle_speed / self.max_spindle_rev)
                widget.set_value(value_to_set)
                real_spindle_speed = self.max_spindle_rev
            elif real_spindle_speed < self.min_spindle_rev:
                value_to_set = widget.get_value() / (real_spindle_speed / self.min_spindle_rev)
                widget.set_value(value_to_set)
                real_spindle_speed = self.min_spindle_rev
            else:
                value_to_set = spindle_override * 100
            self.command.spindleoverride(value_to_set / 100)
        except:
            pass
        self.widgets.lbl_spindle_act.set_text("S %d" % real_spindle_speed)

    def on_adj_start_spindle_RPM_value_changed(self, widget, data = None):
        self.spindle_start_rpm = widget.get_value()
        if self.log: self._add_alarm_entry("sbtn_spindle_start_rpm changed to %s" % self.spindle_start_rpm)
        self.prefs.putpref("spindle_start_rpm", self.spindle_start_rpm, float)

    def on_adj_spindle_bar_min_value_changed(self, widget, data = None):
        self.min_spindle_rev = widget.get_value()
        if self.log: self._add_alarm_entry("Spindle bar min has been set to %s" % self.min_spindle_rev)
        self.prefs.putpref("spindle_bar_min", self.min_spindle_rev, float)
        self.widgets.spindle_feedback_bar.set_property("min", self.min_spindle_rev)

    def on_adj_spindle_bar_max_value_changed(self, widget, data = None):
        self.max_spindle_rev = widget.get_value()
        if self.log: self._add_alarm_entry("Spindle bar max has been set to %s" % self.max_spindle_rev)
        self.prefs.putpref("spindle_bar_max", self.max_spindle_rev, float)
        self.widgets.spindle_feedback_bar.set_property("max", self.max_spindle_rev)

    # Coolant an mist coolant button
    def on_tbtn_flood_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("tbtn_flood_clicked, flood is now %s" % self.stat.flood)
        if self.stat.flood and self.widgets.tbtn_flood.get_active():
            return
        elif not self.stat.flood and not self.widgets.tbtn_flood.get_active():
            return
        elif self.widgets.tbtn_flood.get_active():
            self.widgets.tbtn_flood.set_image(self.widgets.img_coolant_on)
            self.command.flood(linuxcnc.FLOOD_ON)
        else:
            self.widgets.tbtn_flood.set_image(self.widgets.img_coolant_off)
            self.command.flood(linuxcnc.FLOOD_OFF)

    def on_tbtn_mist_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("tbtn_mist_clicked")
        if self.stat.mist and self.widgets.tbtn_mist.get_active():
            return
        elif not self.stat.mist and not self.widgets.tbtn_mist.get_active():
            return
        elif self.widgets.tbtn_mist.get_active():
            self.widgets.tbtn_mist.set_image(self.widgets.img_mist_on)
            self.command.mist(linuxcnc.MIST_ON)
        else:
            self.widgets.tbtn_mist.set_image(self.widgets.img_mist_off)
            self.command.mist(linuxcnc.MIST_OFF)

    # feed stuff
    def on_adj_feed_value_changed(self, widget, data = None):
        if not self.initialized:
            return
        self.command.feedrate(widget.get_value() / 100)
        self.widgets.adj_max_vel.set_value(float(self.widgets.adj_max_vel.upper * widget.get_value() / 100))

    def on_btn_feed_100_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_feed_100_clicked")
        self.widgets.adj_feed.set_value(100)

    def on_adj_jog_vel_value_changed(self, widget, data = None):
        pass

    def on_adj_max_vel_value_changed(self, widget, data = None):
        if not self.initialized:
            return
        value = widget.get_value() / 60
        self.command.maxvel(value * (1 / self.faktor))

    # this are the MDI thinks we need
    def on_btn_delete_clicked(self, widget, data = None):
        message = _("Do you really want to delete the MDI history?\n")
        message += _("this will not delete the MDI History file, but will\n")
        message += _("delete the listbox entries for this session")
        result = dialogs.yesno_dialog(self, header = _("Attention!!"), label = message)
        if result:
            self.widgets.hal_mdihistory.model.clear()
        if self.log: self._add_alarm_entry("delete_MDI with result %s" % result)

    def on_tbtn_use_screen2_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("show window 2 set to %s" % widget.get_active())
        self.prefs.putpref("use_screen2", widget.get_active(), bool)
        if widget.get_active():
            self.widgets.window2.show()
            if self.widgets.rbtn_window.get_active():
                try:
                    pos = self.widgets.window1.get_position()
                    size = self.widgets.window1.get_size()
                    left = pos[0] + size[0]
                    self.widgets.window2.move(left, pos[1])
                except:
                    pass
        else:
            self.widgets.window2.hide()

    def on_btn_show_kbd_clicked(self, widget, data = None):
        # if the image is img_brake macro, we want to interupt the running macro
        if self.widgets.btn_show_kbd.get_image() == self.widgets.img_brake_macro:
            if self.log: self._add_alarm_entry("btn_brake macro_clicked")
            self.command.abort()
            for btn in self.macrobuttons:
                btn.set_sensitive(True)
            self.widgets.btn_show_kbd.set_image(self.widgets.img_keyboard)
            self.widgets.btn_show_kbd.set_property("tooltip-text", _("This button will show or hide the keyboard"))
        elif self.widgets.ntb_info.get_current_page() == 1:
            if self.log: self._add_alarm_entry("btn_keyboard_clicked")
            self.widgets.ntb_info.set_current_page(0)
        else:
            self.widgets.ntb_info.set_current_page(1)
        # special case if we are in edit mode
        if self.widgets.ntb_button.get_current_page() == 6:
            if self.widgets.ntb_info.get_visible():
                self.widgets.box_info.set_size_request(-1, 50)
                self.widgets.ntb_info.hide()
            else:
                self.widgets.box_info.set_size_request(-1, 250)
                self.widgets.ntb_info.show()

    def on_ntb_info_switch_page(self, widget, page, page_num, data = None):
        if self.stat.task_mode == linuxcnc.MODE_MDI:
            self.widgets.hal_mdihistory.entry.grab_focus()
        elif self.stat.task_mode == linuxcnc.MODE_AUTO:
            self.widgets.gcode_view.grab_focus()

    # Three back buttons to be able to leave notebook pages
    # All use the same callback offset
    def on_btn_back_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_back_clicked")
        if self.widgets.ntb_button.get_current_page() == 6: # edit mode, go back to auto_buttons
            self.widgets.ntb_button.set_current_page(2)
        elif self.widgets.ntb_button.get_current_page() == 8: # File selection mode
            self.widgets.ntb_button.set_current_page(2)
        else: # else we go to main button on manual
            self.widgets.ntb_button.set_current_page(0)
            self.widgets.ntb_main.set_current_page(0)
            self.widgets.ntb_preview.set_current_page(0)

    # The offset settings, set to zero
    def on_btn_touch_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_touch_clicked")
        self.widgets.ntb_button.set_current_page(4)
        self._show_offset_tab(True)
        if self.widgets.rbtn_show_preview.get_active():
            self.widgets.ntb_preview.set_current_page(0)

    def on_tbtn_edit_offsets_toggled(self, widget, data = None):
        state = widget.get_active()
        self.widgets.offsetpage1.edit_button.set_active(state)
        widgetlist = ["btn_zero_x", "btn_zero_y", "btn_zero_z", "btn_set_value_x", "btn_set_value_y",
                      "btn_set_value_z", "btn_set_selected", "ntb_jog", "btn_set_selected", "btn_zero_g92"
                     ]
        self._sensitize_widgets(widgetlist, not state)

        if state:
            self.widgets.ntb_preview.set_current_page(1)
        else:
            self.widgets.ntb_preview.set_current_page(0)

        # we have to replace button calls in our list to make all hardware button
        # activate the correct button call
        if state and self.widgets.chk_use_tool_measurement.get_active():
            self.widgets.btn_zero_g92.show()
            self.widgets.btn_block_height.hide()
            self._replace_list_item(4, "btn_block_height", "btn_zero_g92")
        elif not state and self.widgets.chk_use_tool_measurement.get_active():
            self.widgets.btn_zero_g92.hide()
            self.widgets.btn_block_height.show()
            self._replace_list_item(4, "btn_zero_g92", "btn_block_height")

        if not state: # we must switch back to manual mode, otherwise jogging is not possible
            self.command.mode(linuxcnc.MODE_MANUAL)
            self.command.wait_complete()

        # show virtual keyboard?
        if state and self.widgets.chk_use_kb_on_offset.get_active():
            self.widgets.ntb_info.set_current_page(1)
            self.widgets.ntb_preview.set_current_page(1)

    def on_btn_zero_g92_clicked(self, widget, data = None):
        # self.widgets.offsetpage1.zero_g92(self)
        self.command.mode(linuxcnc.MODE_MDI)
        self.command.wait_complete()
        self.command.mdi("G92.1")
        self.command.mode(linuxcnc.MODE_MANUAL)
        self.command.wait_complete()
        self.widgets.btn_touch.emit("clicked")

# TODO: what to do when there are more axis?
# all over one handler with "G10 L20 P0 %s%f"%(axis,value)
    def on_btn_zero_x_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_zero_X_clicked")
        self.command.mode(linuxcnc.MODE_MDI)
        self.command.wait_complete()
        self.command.mdi("G10 L20 P0 X0")
        self.widgets.hal_action_reload.emit("activate")
        self.command.mode(linuxcnc.MODE_MANUAL)
        self.command.wait_complete()

    def on_btn_zero_y_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_zero_Y_clicked")
        self.command.mode(linuxcnc.MODE_MDI)
        self.command.wait_complete()
        self.command.mdi("G10 L20 P0 Y0")
        self.widgets.hal_action_reload.emit("activate")
        self.command.mode(linuxcnc.MODE_MANUAL)
        self.command.wait_complete()

    def on_btn_zero_z_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_zero_Z_clicked")
        self.command.mode(linuxcnc.MODE_MDI)
        self.command.wait_complete()
        self.command.mdi("G10 L20 P0 Z0")
        self.widgets.hal_action_reload.emit("activate")
        self.command.mode(linuxcnc.MODE_MANUAL)
        self.command.wait_complete()

    def on_btn_set_value_clicked(self, widget, data = None):
        if widget == self.widgets.btn_set_value_x:
            axis = "x"
        elif widget == self.widgets.btn_set_value_y:
            axis = "y"
        elif widget == self.widgets.btn_set_value_z:
            axis = "z"
        else:
            axis = "Unknown"
            self._add_alarm_entry(_("Offset %s could not be set, because off unknown axis") % axis)
            return
        self._add_alarm_entry("btn_set_value_%s_clicked" % axis)
        preset = self.prefs.getpref("offset_axis_%s" % axis, 0, float)
        offset = dialogs.entry_dialog(self, data = preset, header = _("Enter value for axis %s") % axis,
                                   label = _("Set axis %s to:") % axis, integer = False)
        if offset == "CANCEL" or offset == "ERROR":
            return
        if offset != False or offset == 0:
            self._add_alarm_entry(_("offset {0} set to {1:f}").format(axis, offset))
            self.command.mode(linuxcnc.MODE_MDI)
            self.command.wait_complete()
            command = "G10 L20 P0 %s%f" % (axis, offset)
            self.command.mdi(command)
            self.widgets.hal_action_reload.emit("activate")
            self.command.mode(linuxcnc.MODE_MANUAL)
            self.command.wait_complete()
            self.prefs.putpref("offset_axis_%s" % axis, offset, float)
        else:
            print(_("Conversion error in btn_set_value"))
            self._add_alarm_entry(_("Offset conversion error because off wrong entry"))
            dialogs.warning_dialog(self, _("Conversion error in btn_set_value!"),
                                  _("Please enter only numerical values\nValues have not been applied"))
# TODO: End

    def on_btn_set_selected_clicked(self, widget, data = None):
        system , name = self.widgets.offsetpage1.get_selected()
        if not system:
            message = _("you did not selected a system to be changed to, so nothing will be changed")
            dialogs.warning_dialog(self, _("Important Warning!"), message)
            self._add_alarm_entry(message)
            return
        if system == self.system_list[self.stat.g5x_index]:
            return
        else:
            self.command.mode(linuxcnc.MODE_MDI)
            self.command.wait_complete()
            self.command.mdi(system)
            self.command.mode(linuxcnc.MODE_MANUAL)
            self.command.wait_complete()

    def on_spbtn_probe_height_value_changed(self, widget, data = None):
        self.halcomp["probeheight"] = widget.get_value()
        self.prefs.putpref("probeheight", widget.get_value(), float)

    def on_spbtn_search_vel_value_changed(self, widget, data = None):
        self.halcomp["searchvel"] = widget.get_value()
        self.prefs.putpref("searchvel", widget.get_value(), float)

    def on_spbtn_probe_vel_value_changed(self, widget, data = None):
        self.halcomp["probevel"] = widget.get_value()
        self.prefs.putpref("probevel", widget.get_value(), float)

    def on_chk_use_tool_measurement_toggled(self, widget, data = None):
        if widget.get_active():
            self.widgets.frm_probe_pos.set_sensitive(True)
            self.widgets.frm_probe_vel.set_sensitive(True)
            self.halcomp["toolmeasurement"] = True
        else:
            self.widgets.frm_probe_pos.set_sensitive(False)
            self.widgets.frm_probe_vel.set_sensitive(False)
            self.halcomp["toolmeasurement"] = False
        self.prefs.putpref("use_toolmeasurement", widget.get_active(), bool)

    def on_chk_hide_axis_4_toggled(self, widget, data = None):
        if not self.initialized:
            return
        state = widget.get_active()
        if self.log: self._add_alarm_entry("Hide axis 4 has been toggled to ", state)
        self.prefs.putpref("hide_axis_4", state, bool)
        self._hide_axis_4(state)
        self._init_offsetpage()
        self._init_tooleditor()

    def on_btn_block_height_clicked(self, widget, data = None):
        probeheight = self.widgets.spbtn_probe_height.get_value()
        blockheight = dialogs.entry_dialog(self, data = None, header = _("Enter the block height"),
                                   label = _("Block height measured from base table"), integer = False)

        if blockheight == "CANCEL" or blockheight == "ERROR":
            return
        if blockheight != False or blockheight == 0:
            self.halcomp["blockheight"] = blockheight
            self.halcomp["probeheight"] = probeheight
            self.prefs.putpref("blockheight", blockheight, float)
            self.prefs.putpref("probeheight", probeheight, float)
        else:
            self.prefs.putpref("blockheight", 0.0, float)
            self.prefs.putpref("probeheight", 0.0, float)
            print(_("Conversion error in btn_block_height"))
            self._add_alarm_entry(_("Offset conversion error because off wrong entry"))
            dialogs.warning_dialog(self, _("Conversion error in btn_block_height!"),
                                  _("Please enter only numerical values\nValues have not been applied"))

        # set koordinate system to new origin
        origin = self.get_ini_info.get_axis_2_min_limit() + blockheight
        self.command.mode(linuxcnc.MODE_MDI)
        self.command.wait_complete()
        self.command.mdi("G10 L2 P0 Z%s" % origin)
        self.widgets.hal_action_reload.emit("activate")
        self.command.mode(linuxcnc.MODE_MANUAL)
        self.command.wait_complete()

    # choose a theme to aply
    def on_theme_choice_changed(self, widget):
        theme = widget.get_active_text()
        if theme == None:
            return
        if self.log: self._add_alarm_entry("theme changed to %s" % widget.get_active_text())
        self.prefs.putpref('gtk_theme', theme, str)
        settings = gtk.settings_get_default()
        if theme == "Follow System Theme":
            theme = self.default_theme
        settings.set_string_property("gtk-theme-name", theme, "")

    def on_rbt_unlock_toggled(self, widget, data = None):
        if widget.get_active():
            if widget == self.widgets.rbt_use_unlock:
                self.prefs.putpref("unlock_way", "use", str)
            elif widget == self.widgets.rbt_no_unlock:
                self.prefs.putpref("unlock_way", "no", str)
            else:
                self.prefs.putpref("unlock_way", "hal", str)

    def on_rbtn_run_from_line_toggled(self, widget, data = None):
        if widget.get_active():
            if widget == self.widgets.rbtn_no_run_from_line:
                self.prefs.putpref("run_from_line", "no_run", str)
                self.widgets.btn_from_line.set_sensitive(False)
            else: # widget == self.widgets.rbtn_run_from_line:
                self.prefs.putpref("run_from_line", "run", str)
                self.widgets.btn_from_line.set_sensitive(True)

    def on_chk_use_kb_on_offset_toggled(self, widget, data = None):
        self.prefs.putpref("show_keyboard_on_offset", widget.get_active(), bool)

    def on_chk_use_kb_on_tooledit_toggled(self, widget, data = None):
        self.prefs.putpref("show_keyboard_on_tooledit", widget.get_active(), bool)

    def on_chk_use_kb_on_edit_toggled(self, widget, data = None):
        self.prefs.putpref("show_keyboard_on_edit", widget.get_active(), bool)

    def on_chk_use_kb_on_mdi_toggled(self, widget, data = None):
        self.prefs.putpref("show_keyboard_on_mdi", widget.get_active(), bool)

    def on_chk_use_kb_on_file_selection_toggled(self, widget, data = None):
        self.prefs.putpref("show_keyboard_on_file_selection", widget.get_active(), bool)

    def on_chk_use_kb_shortcuts_toggled(self, widget, data = None):
        self.prefs.putpref("use_keyboard_shortcuts", widget.get_active(), bool)

    def on_rbtn_show_preview_toggled(self, widget, data = None):
        self.prefs.putpref("show_preview_on_offset", widget.get_active(), bool)

    def on_adj_scale_max_vel_value_changed(self, widget, data = None):
        self.prefs.putpref("scale_max_vel", widget.get_value(), float)
        self.scale_max_vel = widget.get_value()

    def on_adj_scale_jog_vel_value_changed(self, widget, data = None):
        self.prefs.putpref("scale_jog_vel", widget.get_value(), float)
        self.scale_jog_vel = widget.get_value()

    def on_adj_scale_feed_override_value_changed(self, widget, data = None):
        self.prefs.putpref("scale_feed_override", widget.get_value(), float)
        self.scale_feed_override = widget.get_value()

    def on_adj_scale_spindle_override_value_changed(self, widget, data = None):
        self.prefs.putpref("scale_spindle_override", widget.get_value(), float)
        self.scale_spindle_override = widget.get_value()

    def on_rbtn_fullscreen_toggled(self, widget):
        if self.log: self._add_alarm_entry("rbtn_fullscreen_toggled to %s" % widget.get_active())
        if widget.get_active():
            self.widgets.window1.fullscreen()
            self.prefs.putpref("screen1", "fullscreen", str)
        else:
            self.widgets.window1.unfullscreen()

    def on_rbtn_maximized_toggled(self, widget):
        if self.log: self._add_alarm_entry("rbtn_maximized_toggled to %s" % widget.get_active())
        if widget.get_active():
            self.widgets.window1.maximize()
            self.prefs.putpref("screen1", "maximized", str)
        else:
            self.widgets.window1.unmaximize()

    def on_rbtn_window_toggled(self, widget):
        if self.log: self._add_alarm_entry("rbtn_window_toggled to %s" % widget.get_active())
        self.widgets.spbtn_x_pos.set_sensitive(widget.get_active())
        self.widgets.spbtn_y_pos.set_sensitive(widget.get_active())
        self.widgets.spbtn_width.set_sensitive(widget.get_active())
        self.widgets.spbtn_height.set_sensitive(widget.get_active())
        # we have to check also if the window is active, because the button is toggled the first time
        # before the window is shown
        if widget.get_active() and self.widgets.window1.is_active():
            self.widgets.window1.move(int(self.widgets.adj_x_pos.get_value()),
                                      int(self.widgets.adj_y_pos.get_value()))
            self.widgets.window1.resize(int(self.widgets.adj_width.get_value()),
                                        int(self.widgets.adj_height.get_value()))
            self.prefs.putpref("screen1", "window", str)

    def on_adj_x_pos_value_changed(self, widget, data = None):
        self.prefs.putpref("x_pos", widget.get_value(), float)
        ypos = int(self.prefs.getpref("y_pos", 10, float))
        self.widgets.window1.move(int(widget.get_value()), ypos)

    def on_adj_y_pos_value_changed(self, widget, data = None):
        self.prefs.putpref("y_pos", widget.get_value(), float)
        xpos = int(self.prefs.getpref("x_pos", 10, float))
        self.widgets.window1.move(xpos, int(widget.get_value()))

    def on_adj_width_value_changed(self, widget, data = None):
        self.prefs.putpref("width", widget.get_value(), float)
        height = int(self.prefs.getpref("height", 750, float))
        self.widgets.window1.resize(int(widget.get_value()), height)

    def on_adj_height_value_changed(self, widget, data = None):
        self.prefs.putpref("height", widget.get_value(), float)
        width = int(self.prefs.getpref("width", 979, float))
        self.widgets.window1.resize(width, int(widget.get_value()))

    def on_adj_dro_size_value_changed(self, widget, data = None):
        if not self.initialized:
            return
        value = int(widget.get_value())
        self.prefs.putpref("dro_size", value, int)
        self.dro_size = value
        self._init_axis_four()

    def on_chk_hide_cursor_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("hide_cursor_toggled to %s" % widget.get_active())
        self.prefs.putpref("hide_cursor", widget.get_active(), bool)
        self.hide_cursor = widget.get_active()
        if widget.get_active():
            self.widgets.window1.window.set_cursor(INVISABLE)
        else:
            self.widgets.window1.window.set_cursor(None)
        self.abs_color = self.prefs.getpref("abs_color", "blue", str)
        self.rel_color = self.prefs.getpref("rel_color", "black", str)
        self.dtg_color = self.prefs.getpref("dtg_color", "yellow", str)
        self.homed_color = self.prefs.getpref("homed_color", "green", str)
        self.unhomed_color = self.prefs.getpref("unhomed_color", "red", str)

    def on_rel_colorbutton_color_set(self, widget):
        color = widget.get_color()
        if self.log: self._add_alarm_entry("rel color set to %s" % color)
        self.prefs.putpref('rel_color', color, str)
        self._change_dro_color("rel_color", color)
        self.rel_color = str(color)

    def on_abs_colorbutton_color_set(self, widget):
        color = widget.get_color()
        if self.log: self._add_alarm_entry("abs color set to %s" % color)
        self.prefs.putpref('abs_color', widget.get_color(), str)
        self._change_dro_color("abs_color", color)
        self.abs_color = str(color)

    def on_dtg_colorbutton_color_set(self, widget):
        color = widget.get_color()
        if self.log: self._add_alarm_entry("dtg color set to %s" % color)
        self.prefs.putpref('dtg_color', widget.get_color(), str)
        self._change_dro_color("dtg_color", color)
        self.dtg_color = str(color)

    def on_homed_colorbtn_color_set(self, widget):
        color = widget.get_color()
        if self.log: self._add_alarm_entry("homed color set to %s" % color)
        self.prefs.putpref('homed_color', widget.get_color(), str)
        self._change_dro_color("homed_color", color)
        self.homed_color = str(color)

    def on_unhomed_colorbtn_color_set(self, widget):
        color = widget.get_color()
        if self.log: self._add_alarm_entry("unhomed color set to %s" % color)
        self.prefs.putpref('unhomed_color', widget.get_color(), str)
        self._change_dro_color("unhomed_color", color)
        self.unhomed_color = str(color)

    def on_file_to_load_chooser_file_set(self, widget):
        if self.log: self._add_alarm_entry("file to load on startup set to : %s" % widget.get_filename())
        self.prefs.putpref("open_file", widget.get_filename(), str)

    def on_jump_to_dir_chooser_file_set(self, widget, data = None):
        if self.log: self._add_alarm_entry("jump to dir has been set to : %s" % widget.get_filename())
        self.prefs.putpref("jump_to_dir", widget.get_filename(), str)
        self.widgets.IconFileSelection1.set_property("jump_to_dir", widget.get_filename())

    def on_grid_size_value_changed(self, widget, data = None):
        self.widgets.gremlin.set_property('grid_size', widget.get_value())
        self.prefs.putpref('grid_size', widget.get_value(), float)

    def on_tbtn_log_actions_toggled(self, widget, data = None):
        self.log = widget.get_active()
        self.prefs.putpref("log_actions", widget.get_active(), bool)

    def on_chk_show_dro_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("show_gremlin_DRO =  %s" % widget.get_active())
        self.widgets.gremlin.set_property("metric_units", self.widgets.Combi_DRO_x.metric_units)
        self.widgets.gremlin.set_property("enable_dro", widget.get_active())
        self.prefs.putpref("enable_dro", widget.get_active(), bool)
        self.widgets.chk_show_offsets.set_sensitive(widget.get_active())
        self.widgets.chk_show_dtg.set_sensitive(widget.get_active())

    def on_chk_show_dtg_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("show_gremlin_DTG =  %s" % widget.get_active())
        self.widgets.gremlin.set_property("show_dtg", widget.get_active())
        self.prefs.putpref("show_dtg", widget.get_active(), bool)

    def on_chk_show_offsets_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("show_offset_button_toggled to %s" % widget.get_active())
        self.widgets.gremlin.show_offsets = widget.get_active()
        self.prefs.putpref("show_offsets", widget.get_active(), bool)

    def on_cmb_mouse_button_mode_changed(self, widget):
        index = widget.get_active()
        self.widgets.gremlin.set_property("mouse_btn_mode", index)
        self.prefs.putpref("mouse_btn_mode", index, int)

    # tool stuff
    def on_btn_tool_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_tool_clicked")
        if self.widgets.tbtn_fullsize_preview.get_active():
            self.widgets.tbtn_fullsize_preview.set_active(False)
        self.widgets.ntb_button.set_current_page(7)
        self._show_tooledit_tab(True)

    # Here we create a manual tool change dialog
    def on_tool_change(self, widget):
        change = self.halcomp['toolchange-change']
        toolnumber = self.halcomp['toolchange-number']
        if change:
            # if toolnumber = 0 we will get an error because we will not be able to get
            # any tooldescription, so we avoid that case
            if toolnumber == 0:
                message = _("Please remove the mounted tool and press OK when done")
            else:
                tooldescr = self.widgets.tooledit1.get_toolinfo(toolnumber)[16]
                message = _("Please change to tool\n\n# {0:d}     {1}\n\n then click OK.").format(toolnumber, tooldescr)
            result = dialogs.warning_dialog(self, message, title = _("Manual Toolchange"))
            if result :
                self.halcomp["toolchange-changed"] = True
            else:
                print"toolchange abort", self.stat.tool_in_spindle, self.halcomp['toolchange-number']
                self.command.abort()
                self.halcomp['toolchange-number'] = self.stat.tool_in_spindle
                self.halcomp['toolchange-change'] = False
                self.halcomp['toolchange-changed'] = True
                message = _("Tool Change has been aborted!\n")
                message += _("The old tool will remain set!")
                dialogs.warning_dialog(self, message)
        else:
            self.halcomp['toolchange-changed'] = False

    def on_btn_delete_tool_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("on_btn_delete_tool_clicked")
        self.tooledit_btn_delete_tool.emit("clicked")

    def on_btn_add_tool_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("on_btn_add_tool_clicked")
        self.tooledit_btn_add_tool.emit("clicked")

    def on_btn_reload_tooltable_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("on_btn_reload_tooltable_clicked")
        self.tooledit_btn_reload_tool.emit("clicked")

    def on_btn_apply_tool_changes_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("on_btn_apply_tool_changes_clicked")
        self.tooledit_btn_apply_tool.emit("clicked")
        tool = self.widgets.tooledit1.get_selected_tool()

    def on_btn_tool_touchoff_clicked(self, widget, data = None):
        if not self.widgets.tooledit1.get_selected_tool():
            message = _("No or more than one tool selected in tool table")
            message += _("Please select only one tool in the table")
            print(message)
            self._add_alarm_entry(message)
            dialogs.warning_dialog(self, _("Warning Tool Touch off not possible!"), message)
            return

        if self.widgets.tooledit1.get_selected_tool() != self.stat.tool_in_spindle:
            message = _("you can not touch of a tool, witch is not mounted in the spindle")
            message += _("your selection has been reseted to the tool in spindle")
            print(message)
            self._add_alarm_entry(message)
            dialogs.warning_dialog(self, _("Warning Tool Touch off not possible!"), message)
            self.widgets.tooledit1.reload(self)
            self.widgets.tooledit1.set_selected_tool(self.stat.tool_in_spindle)
            return

        if "G41" in self.active_gcodes or "G42" in self.active_gcodes:
            message = _("Tool touch off is not possible with cutter radius compensation switched on!\n")
            message += _("Please emit an G40 before tool touch off")
            print(message)
            self._add_alarm_entry(message)
            dialogs.warning_dialog(self, _("Warning Tool Touch off not possible!"), message)
            return

        if widget == self.widgets.btn_tool_touchoff_x:
            axis = "x"
        elif widget == self.widgets.btn_tool_touchoff_z:
            axis = "z"
        else:
            dialogs.warning_dialog(self, _("Real big error!"),
                                  _("You managed to come to a place that is not possible in on_btn_tool_touchoff"))
            return

        value = dialogs.entry_dialog(self, data = None,
                                  header = _("Enter value for axis %s to set:") % axis.upper(),
                                  label = _("Set parameter of tool {0:d} and axis {1} to:").format(self.stat.tool_in_spindle, axis.upper()),
                                  integer = False)

        if value == "ERROR":
            message = _("Conversion error because of wrong entry for touch off axis %s") % axis.upper()
            print(message)
            self._add_alarm_entry(message)
            dialogs.warning_dialog(self, _("Conversion error !"), message)
            return
        elif value == "CANCEL":
            self._add_alarm_entry(_("entry for axis %s has been canceled") % axis.upper())
            return
        else:
            self._add_alarm_entry(_("axis {0} , has been set to {1:f}").format(axis.upper(), value))
            command = "G10 L10 P%d %s%f" % (self.stat.tool_in_spindle, axis, value)
            self.command.mode(linuxcnc.MODE_MDI)
            self.command.wait_complete()
            self.command.mdi(command)
            self.command.wait_complete()
            if "G43" in self.active_gcodes:
                self.command.mdi("G43")
                self.command.wait_complete()
            self.command.mode(linuxcnc.MODE_MANUAL)
            self.command.wait_complete()

    # select a tool entering a number
    def on_btn_select_tool_by_no_clicked(self, widget, data = None):
        value = dialogs.entry_dialog(self, data = None, header = _("Enter the tool number as integer "),
                                   label = _("Select the tool to change"), integer = True)
        if value == "ERROR":
            message = _("Conversion error because of wrong entry for tool number\n")
            message += _("enter only integer nummbers")
            print(message)
            self._add_alarm_entry(message)
            dialogs.warning_dialog(self, _("Conversion error !"), message)
            return
        elif value == "CANCEL":
            self._add_alarm_entry(_("entry for selection of tool number has been canceled"))
            return
        elif int(value) == self.stat.tool_in_spindle:
            message = _("Selected tool is already in spindle, no change needed.")
            dialogs.warning_dialog(self, _("Important Warning!"), message)
            self._add_alarm_entry(message)
            return
        else:
            self.tool_change = True
            self.command.mode(linuxcnc.MODE_MDI)
            self.command.wait_complete()
            command = "T%s M6" % int(value)
            self.command.mdi(command)

    # set tool with M61 Q? or with T? M6
    def on_btn_selected_tool_clicked(self, widget, data = None):
        tool = self.widgets.tooledit1.get_selected_tool()
        if tool == None:
            message = _("you selected no or more than one tool, the tool selection must be unique")
            dialogs.warning_dialog(self, _("Important Warning!"), message)
            self._add_alarm_entry(message)
            return
        if tool == self.stat.tool_in_spindle:
            message = _("Selected tool is already in spindle, no change needed.")
            dialogs.warning_dialog(self, _("Important Warning!"), message)
            self._add_alarm_entry(message)
            return
        if tool or tool == 0:
            self.tool_change = True
            tool = int(tool)
            self.command.mode(linuxcnc.MODE_MDI)
            self.command.wait_complete()

            if widget == self.widgets.btn_change_tool:
                command = "T%s M6" % tool
            else:
                command = "M61 Q%s" % tool
            self.command.mdi(command)
            if self.log: self._add_alarm_entry("set_tool_with %s" % command)
        else:
            message = _("Could not understand the entered tool number. Will not change anything")
            dialogs.warning_dialog(self, _("Important Warning!"), message)

    # gremlin relevant calls
    def on_rbt_view_p_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_view_p_toggled")
        if self.widgets.rbt_view_p.get_active():
            self.widgets.gremlin.set_property("view", "p")
        self.prefs.putpref("gremlin_view", "rbt_view_p", str)

    def on_rbt_view_x_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_view_x_toggled")
        if self.widgets.rbt_view_x.get_active():
            self.widgets.gremlin.set_property("view", "x")
        self.prefs.putpref("gremlin_view", "rbt_view_x", str)

    def on_rbt_view_y_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_view_y_toggled")
        if self.widgets.rbt_view_y.get_active():
            self.widgets.gremlin.set_property("view", "y")
        self.prefs.putpref("gremlin_view", "rbt_view_y", str)

    def on_rbt_view_z_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_view_z_toggled")
        if self.widgets.rbt_view_z.get_active():
            self.widgets.gremlin.set_property("view", "z")
        self.prefs.putpref("gremlin_view", "rbt_view_z", str)

    def on_rbt_view_y2_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("rbt_view_y2_toggled")
        if self.widgets.rbt_view_y2.get_active():
            self.widgets.gremlin.set_property("view", "y2")
        self.prefs.putpref("gremlin_view", "rbt_view_y2", str)

    def on_btn_zoom_in_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_zoom_in_clicked")
        self.widgets.gremlin.zoom_in()

    def on_btn_zoom_out_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_zoom_out_clicked")
        self.widgets.gremlin.zoom_out()

    def on_btn_delete_view_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_delete_view_clicked")
        self.widgets.gremlin.clear_live_plotter()

    def on_tbtn_view_dimension_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("tbtn_view_dimensions_toggled")
        self.widgets.gremlin.set_property("show_extents_option", widget.get_active())
        self.prefs.putpref("view_dimension", self.widgets.tbtn_view_dimension.get_active(), bool)

    def on_tbtn_view_tool_path_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_view_tool_path_clicked")
        self.widgets.gremlin.set_property("show_live_plot", widget.get_active())
        self.prefs.putpref("view_tool_path", self.widgets.tbtn_view_tool_path.get_active(), bool)

    def on_gremlin_line_clicked(self, widget, line):
        self.widgets.gcode_view.set_line_number(line)

    def on_btn_load_clicked(self, widget, data = None):
        self.widgets.ntb_button.set_current_page(8)
        self.widgets.ntb_preview.set_current_page(3)
        self.widgets.tbtn_fullsize_preview.set_active(True)
        self._show_iconview_tab(True)
        self.widgets.IconFileSelection1.refresh_filelist()
        self.widgets.IconFileSelection1.iconView.grab_focus()

    def on_btn_sel_next_clicked(self, widget, data = None):
        self.widgets.IconFileSelection1.btn_sel_next.emit("clicked")

    def on_btn_sel_prev_clicked(self, widget, data = None):
        self.widgets.IconFileSelection1.btn_sel_prev.emit("clicked")

    def on_btn_home_clicked(self, widget, data = None):
        self.widgets.IconFileSelection1.btn_home.emit("clicked")

    def on_btn_jump_to_clicked(self, widget, data = None):
        self.widgets.IconFileSelection1.btn_jump_to.emit("clicked")

    def on_btn_dir_up_clicked(self, widget, data = None):
        self.widgets.IconFileSelection1.btn_dir_up.emit("clicked")

    def on_btn_select_clicked(self, widget, data = None):
        self.widgets.IconFileSelection1.btn_select.emit("clicked")

    def on_IconFileSelection1_selected(self, widget, path = None):
        if path:
# FIXME : START
#            try:
            # self.command.program_open( path )
            # self.widgets.gcode_view.load_file( path )
            self.widgets.hal_action_open.load_file(path)
            self.widgets.ntb_preview.set_current_page(0)
            self.widgets.tbtn_fullsize_preview.set_active(False)
            self.widgets.ntb_button.set_current_page(2)
            self._show_iconview_tab(False)
#            except:
#                message = _( "error trying opening file %s" % path )
#                dialogs.warning_dialog(self, _( "Important Warning" ), message )
#                self.notification.add_message( message, INFO_ICON )
# FIXME : END

    def on_IconFileSelection1_exit(self, widget):
        self.widgets.ntb_preview.set_current_page(0)
        self.widgets.tbtn_fullsize_preview.set_active(False)
        self._show_iconview_tab(False)

    # edit a program or make a new one
    def on_btn_edit_clicked(self, widget, data = None):
        if self.log: self._add_alarm_entry("btn_edit_clicked")
        self.widgets.ntb_button.set_current_page(6)
        self.widgets.ntb_preview.hide()
        self.widgets.hbox_dro.hide()
        width = self.widgets.window1.allocation.width
        width -= self.widgets.vbtb_main.allocation.width
        width -= self.widgets.box_right.allocation.width
        width -= self.widgets.box_left.allocation.width
        self.widgets.vbx_jog.set_size_request(width , -1)
        self.widgets.gcode_view.set_sensitive(True)
        self.widgets.gcode_view.grab_focus()
        if self.widgets.chk_use_kb_on_edit.get_active():
            self.widgets.ntb_info.set_current_page(1)
            self.widgets.box_info.set_size_request(-1, 250)
        else:
            self.widgets.ntb_info.hide()
            self.widgets.box_info.set_size_request(-1, 50)
        self.widgets.tbl_search.show()

    # search forward while in edit mode
    def on_btn_search_forward_clicked(self, widget, data = None):
        self.widgets.gcode_view.text_search(direction = True, text = self.widgets.search_entry.get_text())

    # search backward while in edit mode
    def on_btn_search_back_clicked(self, widget, data = None):
        self.widgets.gcode_view.text_search(direction = False, text = self.widgets.search_entry.get_text())

    # undo changes while in edit mode
    def on_btn_undo_clicked(self, widget, data = None):
        self.widgets.gcode_view.undo()

    # redo changes while in edit mode
    def on_btn_redo_clicked(self, widget, data = None):
        self.widgets.gcode_view.redo()

    # if we leave the edit mode, we will have to show all widgets again
    def on_ntb_button_switch_page(self, *args):
        message = "ntb_button_page changed to %s" % self.widgets.ntb_button.get_current_page()
        if self.log: self._add_alarm_entry(message)

        if self.widgets.ntb_preview.get_current_page() == 0: # preview tab is active,
            # check if offset tab is visible, if so we have to hide it
            page = self.widgets.ntb_preview.get_nth_page(1)
            if page.get_visible():
                self._show_offset_tab(False)
        elif self.widgets.ntb_preview.get_current_page() == 1:
            self._show_offset_tab(False)
        elif self.widgets.ntb_preview.get_current_page() == 2:
            self._show_tooledit_tab(False)
        elif self.widgets.ntb_preview.get_current_page() == 3:
            self._show_iconview_tab(False)

        if self.widgets.tbtn_fullsize_preview.get_active():
            self.widgets.tbtn_fullsize_preview.set_active(False)
        if self.widgets.ntb_button.get_current_page() == 6 or self.widgets.ntb_preview.get_current_page() == 3:
            self.widgets.ntb_preview.show()
            self.widgets.hbox_dro.show()
            self.widgets.vbx_jog.set_size_request(360 , -1)
            self.widgets.gcode_view.set_sensitive(0)
            self.widgets.btn_save.set_sensitive(True)
            self.widgets.hal_action_reload.emit("activate")
            self.widgets.ntb_info.set_current_page(0)
            self.widgets.ntb_info.show()
            self.widgets.box_info.set_size_request(-1, 200)
            self.widgets.tbl_search.hide()

    # Save all changes and run the program
    def on_btn_save_and_run_clicked(self, widget, data = None):
        if self.widgets.lbl_program.get_label() == "":
            self.widgets.btn_save_as.emit("clicked")
        else:
            self.widgets.btn_save.emit("clicked")
        self.widgets.hal_action_reload.emit("activate")
        self.widgets.ntb_button.set_current_page(2)
        self.widgets.btn_run.emit("clicked")

    # make a new file
    def on_btn_new_clicked(self, widget, data = None):
        tempfilename = os.path.join(_TEMPDIR, "temp.ngc")
        content = self.get_ini_info.get_RS274_start_code()
        if content == None:
            content = " "
        content += "\n\n\n\nM2"
        gcodefile = open(tempfilename, "w")
        gcodefile.write(content)
        gcodefile.close()
        if self.widgets.lbl_program.get_label() == tempfilename:
            self.widgets.hal_action_reload.emit("activate")
        else:
            self.widgets.hal_action_open.load_file(tempfilename)
            # self.command.program_open(tempfilename)
        self.widgets.gcode_view.grab_focus()
        self.widgets.btn_save.set_sensitive(False)

    def on_tbtn_optional_blocks_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("on_tbtn_optional_blocks_toggled to %s" % widget.get_active())
        self.command.set_block_delete(widget.get_active())
        self.prefs.putpref("blockdel", widget.get_active(), bool)
        self.widgets.hal_action_reload.emit("activate")


    def on_tbtn_optional_stops_toggled(self, widget, data = None):
        if self.log: self._add_alarm_entry("on_tbtn_optional_stops_toggled to %s" % widget.get_active())
        self.command.set_optional_stop(widget.get_active())
        self.prefs.putpref("opstop", widget.get_active(), bool)

    # this can not be done with the status widget,
    # because it will not emit a RESUME signal
    def on_tbtn_pause_toggled(self, widget, data = None):
        if widget.get_active():
            self.command.auto(linuxcnc.AUTO_PAUSE)
        else:
            self.command.auto(linuxcnc.AUTO_RESUME)
        self._add_alarm_entry("Pause toggled to be %s" % widget.get_active())
        widgetlist = ["btn_step", "rbt_forward", "rbt_reverse", "rbt_stop"]
        self._sensitize_widgets(widgetlist, widget.get_active())

    def on_btn_run_clicked(self, widget, data = None):
        self.command.auto(linuxcnc.AUTO_RUN, self.start_line)

    def on_btn_step_clicked(self, widget, data = None):
        self.command.auto(linuxcnc.AUTO_STEP)
        self.stepping = True

    # this is needed only for stepping through a program, to
    # sensitize the widgets according to that mode
    def on_btn_load_state_changed(self, widget, state):
        if state == gtk.STATE_INSENSITIVE:
            self.stepping = False
            self.widgets.tbtn_pause.set_sensitive(True)

    def on_btn_stop_clicked(self, widget, data = None):
        self.command.abort()
        self.start_line = 0
        self.widgets.gcode_view.set_line_number(0)
        self.widgets.tbtn_pause.set_active(False)

    def on_btn_from_line_clicked(self, widget, data = None):
        self._add_alarm_entry("Restart the program from line clicked")
        dialogs.restart_dialog(self)

    def on_change_sound(self, widget, sound = None):
        file = widget.get_filename()
        if file:
            if widget == self.widgets.audio_error_chooser:
                self.error_sound = file
                self.prefs.putpref("audio_error", file, str)
            else:
                self.alert_sound = file
                self.prefs.putpref("audio_alert", file, str)

# =========================================================
# Hal Pin Handling Start
    def _on_fo_counts_changed(self, pin, widget):
        if not self.initialized:
            return
        counts = pin.get()
        difference = (counts - self.fo_counts) * self.scale_feed_override
        self.fo_counts = counts
        val = self.widgets[widget].get_value() + difference
        if val < 0:
            val = 0
        if difference != 0:
            self.widgets[widget].set_value(val)

    def _on_so_counts_changed(self, pin, widget):
        if not self.initialized:
            return
        counts = pin.get()
        difference = (counts - self.so_counts) * self.scale_spindle_override
        self.so_counts = counts
        val = self.widgets[widget].get_value() + difference
        if val < 0:
            val = 0
        if difference != 0:
            self.widgets[widget].set_value(val)

    def _on_jv_counts_changed(self, pin, widget):
        if not self.initialized:
            return
        counts = pin.get()
        difference = (counts - self.jv_counts) * self.scale_jog_vel
        self.jv_counts = counts
        val = self.widgets[widget].get_value() + difference
        if val < 0:
            val = 0
        if difference != 0:
            self.widgets[widget].set_value(val)

    def _on_mv_counts_changed(self, pin, widget):
        if not self.initialized:
            return
        counts = pin.get()
        difference = (counts - self.mv_counts) * self.scale_max_vel
        self.mv_counts = counts
        val = self.widgets[widget].get_value() + difference
        if val < 0:
            val = 0
        if difference != 0:
            self.widgets[widget].set_value(val)

    def _on_unlock_settings_changed(self, pin):
        if not self.widgets.rbt_hal_unlock.get_active():
            return
        self.widgets.tbtn_setup.set_sensitive(pin.get())

    def _on_message_deleted(self, widget, messages):
        number = []
        for message in messages:
            if message[2] == ALERT_ICON:
                number.append(message[0])
        if len(number) == 0:
            self.halcomp["error"] = False

    def _del_message_changed(self, pin):
        if pin.get():
            if self.halcomp["error"] == True:
                number = []
                messages = self.notification.messages
                for message in messages:
                    if message[2] == ALERT_ICON:
                        number.append(message[0])
                self.notification.del_message(number[0])
                if len(number) == 1:
                    self.halcomp["error"] = False
            else:
                self.notification.del_last()

    def _on_pin_incr_changed(self, pin, buttonnumber):
        if not pin.get():
            return
        data = self.jog_increments[int(buttonnumber)]
        self.on_increment_changed(self.incr_rbt_list[int(buttonnumber)], data)
        self.incr_rbt_list[int(buttonnumber)].set_active(True)

    def _on_pin_jog_changed(self, pin, axis, direction):
        if axis not in "xyz":
            axis = "4"
        if direction == 1:
            widget = self.widgets["btn_%s_plus" % axis]
        else:
            widget = self.widgets["btn_%s_minus" % axis]
        if pin.get():
            self.on_btn_jog_pressed(widget)
        else:
            self.on_btn_jog_released(widget)

    def _on_axis_limit_changed(self, pin):
        if not pin.get() or self.stat.task_state == (linuxcnc.STATE_ESTOP or linuxcnc.STATE_OFF):
            return
        if self.halcomp["set-max-limit"] == True:
            self.command.set_max_limit(self.halcomp["axis-to-set"], self.halcomp["limit-value"])
        else:
            self.command.set_min_limit(self.halcomp["axis-to-set"], self.halcomp["limit-value"])

    def _reset_overide(self, pin, type):
        if pin.get():
            self.widgets["btn_%s_100" % type].emit("clicked")

    # The actions of the buttons
    def _on_h_button_changed(self, pin):
        self._add_alarm_entry("got h_button_signal %s" % pin.name)
        # we check if the button is pressed ore release,
        # otehrwise a signal will be emitted, wenn the button is released and
        # the signal drob down to zero
        if not pin.get():
            return
        # lets see on witch button_box we are
        page = self.widgets.ntb_button.get_current_page()
        # witch button has been pressed
        btn = str(pin.name)
        # from the list we declared under __init__ we get the button number
        nr = int(btn[-1])
        tab = self.h_tabs[page] # see in the __init__ section for the declaration of self.tabs
        button = None
        # we check if there is a button or the user pressed a hardware button under
        # a non existing software button
        for index in tab:
            if int(index[0]) == nr:
                # this is the name of the button
                button = index[1]
        if button:
            # only emit a signal if the button is sensitive, otherwise
            # running actions may be interupted
            if self.widgets[button].get_sensitive() == False:
                print("%s not_sensitive" % button)
                self._add_alarm_entry("%s not_sensitive" % button)
                return
            self.widgets[button].emit("clicked")
        else:
            # as we are generating the macro buttons dynamecely, we can"t use the same
            # method as above, here is how we do it
            if page == 1: # macro page
                # does the user press a valid hardware button?
                if nr < len(self.macrobuttons):
                    button = self.macrobuttons[nr] # This list is generated in add_macros_buttons(self)
                    # is the button sensitive?
                    if button.get_sensitive() == False:
                        print("%s not_sensitive" % button)
                        return
                    button.emit("pressed")
                else:
                    print("No function on this button")
                    self._add_alarm_entry("%s not_sensitive" % button)
            else:
                print("No function on this button")

    def _on_v_button_changed(self, pin):
        self._add_alarm_entry("got v_button_signal %s" % pin.name)
        if not pin.get():
            return
        btn = str(pin.name)
        nr = int(btn[-1])
        tab = self.v_tabs # see in the __init__ section for the declaration of self.tabs
        button = None
        for index in tab:
            if int(index[0]) == nr:
                # this is the name of the button
                button = index[1]
        if button:
            # only emit a signal if the button is sensitive, otherwise
            # running actions may be interupted
            if self.widgets[button].get_sensitive() == False:
                print("%s not_sensitive" % button)
                self._add_alarm_entry("%s not_sensitive" % button)
                return
            button_pressed_list = ("rbt_manual", "rbt_mdi", "rbt_auto")
            button_toggled_list = ("tbtn_setup")
            if button in button_pressed_list:
                self.widgets[button].set_active(True)
                self.widgets[button].emit("pressed")
            elif button in button_toggled_list:
                self.widgets[button].set_active(not self.widgets[button].get_active())
            else:
                self.widgets[button].emit("clicked")
        else:
            print("No button found in v_tabs from %s" % pin.name)
            self._add_alarm_entry("No button found in v_tabs from %s" % pin.name)

    # We need extra HAL pins here is where we do it.
    # we make pins for the hardware buttons witch can be placed around the
    # screen to activate the coresponding buttons on the GUI
    def _init_hal_pins(self):
        # generate the horizontal button pins
        for h_button in range(0, 10):
            self.signal = hal_glib.GPin(self.halcomp.newpin("h-button-%s" % h_button,
                                                                    hal.HAL_BIT, hal.HAL_IN))
            self.signal.connect("value_changed", self._on_h_button_changed)

        # generate the vertical button pins
        for v_button in range(0, 7):
            self.signal = hal_glib.GPin(self.halcomp.newpin("v-button-%s" % v_button,
                                                                    hal.HAL_BIT, hal.HAL_IN))
            self.signal.connect("value_changed", self._on_v_button_changed)

        # buttons for jogging the axis
        for jog_button in self.axis_list:
            if jog_button not in "xyz":
                jog_button = self.axisletter_four
            self.signal = hal_glib.GPin(self.halcomp.newpin("jog-%s-plus" % jog_button,
                                                                    hal.HAL_BIT, hal.HAL_IN))
            self.signal.connect("value_changed", self._on_pin_jog_changed, jog_button, 1)
            self.signal = hal_glib.GPin(self.halcomp.newpin("jog-%s-minus" % jog_button,
                                                                    hal.HAL_BIT, hal.HAL_IN))
            self.signal.connect("value_changed", self._on_pin_jog_changed, jog_button, -1)

        # jog_increment out pin
        self.jog_increment = hal_glib.GPin(self.halcomp.newpin("jog-increment",
                                                                       hal.HAL_FLOAT, hal.HAL_OUT))

        # generate the pins to set the increments
        for buttonnumber in range(0, len(self.jog_increments)):
            self.signal = hal_glib.GPin(self.halcomp.newpin("jog-inc-%s" % buttonnumber,
                                                                    hal.HAL_BIT, hal.HAL_IN))
            self.signal.connect("value_changed", self._on_pin_incr_changed, buttonnumber)

        self.signal = hal_glib.GPin(self.halcomp.newpin("unlock-settings", hal.HAL_BIT, hal.HAL_IN))
        self.signal.connect("value_changed", self._on_unlock_settings_changed)

        # generate the pins to connect encoders to the sliders
        self.feed_override_counts = hal_glib.GPin(self.halcomp.newpin("feed-override-counts",
                                                                             hal.HAL_S32, hal.HAL_IN))
        self.feed_override_counts.connect("value_changed", self._on_fo_counts_changed, "scl_feed")
        self.spindle_override_counts = hal_glib.GPin(self.halcomp.newpin("spindle-override-counts",
                                                                                hal.HAL_S32, hal.HAL_IN))
        self.spindle_override_counts.connect("value_changed", self._on_so_counts_changed, "scl_spindle")
        self.jog_speed_counts = hal_glib.GPin(self.halcomp.newpin("jog-speed-counts", hal.HAL_S32,
                                                                          hal.HAL_IN))
        self.jog_speed_counts.connect("value_changed", self._on_jv_counts_changed, "scl_jog_vel")
        self.max_vel_counts = hal_glib.GPin(self.halcomp.newpin("max-vel-counts", hal.HAL_S32,
                                                                        hal.HAL_IN))
        self.max_vel_counts.connect("value_changed", self._on_mv_counts_changed, "scl_max_vel")

        # This is only necessary, because after connecting the Encoder the value will be increased by one
        self.widgets.btn_feed_100.emit("clicked")

        # make the pins for tool measurement
        self.probeheight = hal_glib.GPin(self.halcomp.newpin("probeheight", hal.HAL_FLOAT, hal.HAL_OUT))
        self.blockheight = hal_glib.GPin(self.halcomp.newpin("blockheight", hal.HAL_FLOAT, hal.HAL_OUT))
        self.enable_toolmeasurement = hal_glib.GPin(self.halcomp.newpin("toolmeasurement", hal.HAL_BIT, hal.HAL_OUT))
        self.probe_search_vel = hal_glib.GPin(self.halcomp.newpin("searchvel", hal.HAL_FLOAT, hal.HAL_OUT))
        self.probe_vel = hal_glib.GPin(self.halcomp.newpin("probevel", hal.HAL_FLOAT, hal.HAL_OUT))

        # make pins to react to tool_offset changes
        self.pin_offset_x = hal_glib.GPin(self.halcomp.newpin("tooloffset-x", hal.HAL_FLOAT, hal.HAL_IN))
        self.pin_offset_x.connect("value_changed", self._offset_changed, "tooloffset-x")
        self.pin_offset_z = hal_glib.GPin(self.halcomp.newpin("tooloffset-z", hal.HAL_FLOAT, hal.HAL_IN))
        self.pin_offset_z.connect("value_changed", self._offset_changed, "tooloffset-z")

        # make a pin to delete a notification message
        self.pin_del_message = hal_glib.GPin(self.halcomp.newpin("delete-message", hal.HAL_BIT, hal.HAL_IN))
        self.pin_del_message.connect("value_changed", self._del_message_changed)

        # for manual tool change dialog
        self.halcomp.newpin("toolchange-number", hal.HAL_S32, hal.HAL_IN)
        self.halcomp.newpin("toolchange-changed", hal.HAL_BIT, hal.HAL_OUT)
        self.pin_change_tool = hal_glib.GPin(self.halcomp.newpin('toolchange-change', hal.HAL_BIT, hal.HAL_IN))
        self.pin_change_tool.connect('value_changed', self.on_tool_change)

        # make some pin to be able to enlarge the working limits, i.e. if the tool changer is in that place
        # and the soft limits are set to not have colision with the changer, you can use this pin to change
        # the working area, you are responsible to be in the area if you reduce it!
        self.pin_axis_to_set = hal_glib.GPin(self.halcomp.newpin("axis-to-set", hal.HAL_S32, hal.HAL_IN))
        self.pin_set_max_limit = hal_glib.GPin(self.halcomp.newpin("set-max-limit", hal.HAL_BIT, hal.HAL_IN))
        self.pin_limit_value = hal_glib.GPin(self.halcomp.newpin("limit-value", hal.HAL_FLOAT, hal.HAL_IN))
        self.pin_limit_value.connect("value_changed", self._on_axis_limit_changed)

        # make a pin to reset feed override to 100 %
        self.pin_res_feed = hal_glib.GPin(self.halcomp.newpin("reset-feed-override", hal.HAL_BIT, hal.HAL_IN))
        self.pin_res_feed.connect("value_changed", self._reset_overide, "feed")

        # make a pin to reset spindle override to 100 %
        self.pin_res_spindle = hal_glib.GPin(self.halcomp.newpin("reset-spindle-override", hal.HAL_BIT, hal.HAL_IN))
        self.pin_res_spindle.connect("value_changed", self._reset_overide, "spindle")

        # make an error pin to indiocate a error to hardware
        self.halcomp.newpin("error", hal.HAL_BIT, hal.HAL_OUT)

# Hal Pin Handling End
# =========================================================

    def on_gremlin_button_press_event(self, widget, event):
        print widget.get_highlight_line()

if __name__ == "__main__":
    app = gmoccapy()

    inifile = sys.argv[2]
    print ("**** GMOCCAPY INFO : inifile = %s ****:" % sys.argv[2])
    postgui_halfile = app.get_ini_info.get_postgui_halfile()
    print ("**** GMOCCAPY INFO : postgui halfile = %s ****:" % postgui_halfile)

    if postgui_halfile:
        res = os.spawnvp(os.P_WAIT, "halcmd", ["halcmd", "-i", inifile, "-f", postgui_halfile])
        if res:
            raise SystemExit, res
    gtk.main()