Beispiel #1
0
    def __init__(self, master, app):
        CNCRibbon.PageFrame.__init__(self, master, "ProbeCommon", app)

        lframe = tkExtra.ExLabelFrame(self,
                                      text="Common",
                                      foreground="DarkBlue")
        lframe.pack(side=TOP, fill=X)
        frame = lframe.frame

        # ----
        row = 0
        col = 0

        Label(frame, text=_("Probe Feed:")).grid(row=row, column=col, sticky=E)
        col += 1
        ProbeCommonFrame.probeFeed = tkExtra.FloatEntry(frame,
                                                        background="White",
                                                        width=5)
        ProbeCommonFrame.probeFeed.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(ProbeCommonFrame.probeFeed,
                            _("Set probe feed rate"))
        self.addWidget(ProbeCommonFrame.probeFeed)

        # ----
        # Tool offset
        row += 1
        col = 0
        Label(frame, text=_("TLO")).grid(row=row, column=col, sticky=E)
        col += 1
        ProbeCommonFrame.tlo = tkExtra.FloatEntry(frame, background="White")
        ProbeCommonFrame.tlo.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(ProbeCommonFrame.tlo,
                            _("Set tool offset for probing"))
        self.addWidget(ProbeCommonFrame.tlo)
        self.tlo.bind("<Return>", self.tloSet)
        self.tlo.bind("<KP_Enter>", self.tloSet)

        col += 1
        b = Button(frame, text=_("set"), command=self.tloSet, padx=2, pady=1)
        b.grid(row=row, column=col, sticky=EW)
        self.addWidget(b)

        # ---
        # feed command
        row += 1
        col = 0
        Label(frame, text=_("Probe Command")).grid(row=row,
                                                   column=col,
                                                   sticky=E)
        col += 1
        ProbeCommonFrame.probeCmd = tkExtra.Combobox(frame,
                                                     True,
                                                     background="White",
                                                     width=16)
        ProbeCommonFrame.probeCmd.grid(row=row, column=col, sticky=EW)
        ProbeCommonFrame.probeCmd.fill(PROBE_CMD)
        self.addWidget(ProbeCommonFrame.probeCmd)

        frame.grid_columnconfigure(1, weight=1)
        self.loadConfig()
Beispiel #2
0
    def __init__(self, master, app):
        CNCRibbon.PageFrame.__init__(self, master, "Probe:Probe", app)

        # WorkSpace -> Probe
        lframe = LabelFrame(self, text=_("Probe"), foreground="DarkBlue")
        lframe.pack(side=TOP, fill=X)

        row, col = 0, 0
        Label(lframe, text=_("Probe:")).grid(row=row, column=col, sticky=E)

        col += 1
        self._probeX = Label(lframe,
                             foreground="DarkBlue",
                             background="gray95")
        self._probeX.grid(row=row, column=col, padx=1, sticky=EW + S)

        col += 1
        self._probeY = Label(lframe,
                             foreground="DarkBlue",
                             background="gray95")
        self._probeY.grid(row=row, column=col, padx=1, sticky=EW + S)

        col += 1
        self._probeZ = Label(lframe,
                             foreground="DarkBlue",
                             background="gray95")
        self._probeZ.grid(row=row, column=col, padx=1, sticky=EW + S)

        # ---
        row, col = row + 1, 0
        Label(lframe, text=_("Pos:")).grid(row=row, column=col, sticky=E)

        col += 1
        self.probeXdir = tkExtra.FloatEntry(lframe, background="White")
        self.probeXdir.grid(row=row, column=col, sticky=EW + S)
        tkExtra.Balloon.set(self.probeXdir, _("Probe along X direction"))
        self.addWidget(self.probeXdir)

        col += 1
        self.probeYdir = tkExtra.FloatEntry(lframe, background="White")
        self.probeYdir.grid(row=row, column=col, sticky=EW + S)
        tkExtra.Balloon.set(self.probeYdir, _("Probe along Y direction"))
        self.addWidget(self.probeYdir)

        col += 1
        self.probeZdir = tkExtra.FloatEntry(lframe, background="White")
        self.probeZdir.grid(row=row, column=col, sticky=EW + S)
        tkExtra.Balloon.set(self.probeZdir, _("Probe along Z direction"))
        self.addWidget(self.probeZdir)

        lframe.grid_columnconfigure(1, weight=1)
        lframe.grid_columnconfigure(2, weight=1)
        lframe.grid_columnconfigure(3, weight=1)

        self.loadConfig()
Beispiel #3
0
    def __init__(self, master, app):
        CNCRibbon.PageFrame.__init__(self, master, "Probe:Center", app)

        # WorkSpace -> Probe
        lframe = LabelFrame(self, text=_("Center"), foreground="DarkBlue")
        lframe.pack(side=TOP, fill=X)

        Label(lframe, text=_("Diameter:")).pack(side=LEFT)
        self.diameter = tkExtra.FloatEntry(lframe, background="White")
        self.diameter.pack(side=LEFT, fill=X)
        tkExtra.Balloon.set(self.diameter, _("Probing ring internal diameter"))
        self.addWidget(self.diameter)

        self.loadConfig()
Beispiel #4
0
    def __init__(self,
                 master,
                 title,
                 message,
                 input="",
                 type_="str",
                 from_=None,
                 to_=None):

        Toplevel.__init__(self, master)
        self.master = master
        self.transient(master)
        Label(self, text=message, justify=LEFT).pack(expand=YES,
                                                     fill=BOTH,
                                                     side=TOP)

        if type_ == "int":
            self.entry = tkExtra.IntegerEntry(self)
            self.entry.insert(0, input)
            w = self.entry

        elif type_ == "float":
            self.entry = tkExtra.FloatEntry(self)
            self.entry.insert(0, input)
            w = self.entry

        elif type_ == "spin":
            self.entry = IntVar()
            self.entry.set(input)
            w = Spinbox(self, text=self.entry, from_=from_, to_=to_)

        else:  # default str
            self.entry = Entry(self)
            self.entry.insert(0, input)
            w = self.entry

        w.pack(padx=5, expand=YES, fill=X)

        frame = Frame(self)
        b = Button(frame, text="Cancel", command=self.cancel)
        b.pack(side=RIGHT, pady=5)
        b = Button(frame, text="Ok", command=self.ok)
        b.pack(side=RIGHT, pady=5)
        frame.pack(fill=X)

        self.input = None
        self.bind("<Return>", self.ok)
        self.bind("<Escape>", self.cancel)
        self.focus_set()
        w.focus_set()
Beispiel #5
0
    def __init__(self, master, app):
        CNCRibbon.PageFrame.__init__(self, master, "Probe:Tool", app)

        lframe = LabelFrame(self,
                            text=_("Manual Tool Change"),
                            foreground="DarkBlue")
        lframe.pack(side=TOP, fill=X)

        # --- Tool policy ---
        row, col = 0, 0
        Label(lframe, text=_("Policy:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.toolPolicy = tkExtra.Combobox(lframe,
                                           True,
                                           background="White",
                                           command=self.policyChange,
                                           width=16)
        self.toolPolicy.grid(row=row, column=col, columnspan=3, sticky=EW)
        self.toolPolicy.fill(TOOL_POLICY)
        self.toolPolicy.set(TOOL_POLICY[0])
        tkExtra.Balloon.set(self.toolPolicy, _("Tool change policy"))
        self.addWidget(self.toolPolicy)

        # ----
        row += 1
        col = 0
        Label(lframe, text=_("Pause:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.toolWait = tkExtra.Combobox(lframe,
                                         True,
                                         background="White",
                                         command=self.policyChange,
                                         width=16)
        self.toolWait.grid(row=row, column=col, columnspan=3, sticky=EW)
        self.toolWait.fill(TOOL_WAIT)
        self.toolWait.set(TOOL_WAIT[1])
        self.addWidget(self.toolWait)

        # ----
        row += 1
        col = 1
        Label(lframe, text="MX").grid(row=row, column=col, sticky=EW)
        col += 1
        Label(lframe, text="MY").grid(row=row, column=col, sticky=EW)
        col += 1
        Label(lframe, text="MZ").grid(row=row, column=col, sticky=EW)

        # --- Tool Change position ---
        row += 1
        col = 0
        Label(lframe, text=_("Change:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.changeX = tkExtra.FloatEntry(lframe, background="White", width=5)
        self.changeX.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.changeX,
                            _("Manual tool change Machine X location"))
        self.addWidget(self.changeX)

        col += 1
        self.changeY = tkExtra.FloatEntry(lframe, background="White", width=5)
        self.changeY.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.changeY,
                            _("Manual tool change Machine Y location"))
        self.addWidget(self.changeY)

        col += 1
        self.changeZ = tkExtra.FloatEntry(lframe, background="White", width=5)
        self.changeZ.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.changeZ,
                            _("Manual tool change Machine Z location"))
        self.addWidget(self.changeZ)

        col += 1
        b = Button(lframe,
                   text=_("get"),
                   command=self.getChange,
                   padx=2,
                   pady=1)
        b.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(
            b,
            _("Get current gantry position as machine tool change location"))
        self.addWidget(b)

        # --- Tool Probe position ---
        row += 1
        col = 0
        Label(lframe, text=_("Probe:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.probeX = tkExtra.FloatEntry(lframe, background="White", width=5)
        self.probeX.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeX,
                            _("Manual tool change Probing MX location"))
        self.addWidget(self.probeX)

        col += 1
        self.probeY = tkExtra.FloatEntry(lframe, background="White", width=5)
        self.probeY.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeY,
                            _("Manual tool change Probing MY location"))
        self.addWidget(self.probeY)

        col += 1
        self.probeZ = tkExtra.FloatEntry(lframe, background="White", width=5)
        self.probeZ.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeZ,
                            _("Manual tool change Probing MZ location"))
        self.addWidget(self.probeZ)

        col += 1
        b = Button(lframe,
                   text=_("get"),
                   command=self.getProbe,
                   padx=2,
                   pady=1)
        b.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(
            b, _("Get current gantry position as machine tool probe location"))
        self.addWidget(b)

        # --- Probe Distance ---
        row += 1
        col = 0
        Label(lframe, text=_("Distance:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.probeDistance = tkExtra.FloatEntry(lframe,
                                                background="White",
                                                width=5)
        self.probeDistance.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(
            self.probeDistance,
            _("After a tool change distance to scan starting from ProbeZ"))
        self.addWidget(self.probeDistance)

        # --- Calibration ---
        row += 1
        col = 0
        Label(lframe, text=_("Calibration:")).grid(row=row,
                                                   column=col,
                                                   sticky=E)
        col += 1
        self.toolHeight = tkExtra.FloatEntry(lframe,
                                             background="White",
                                             width=5)
        self.toolHeight.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.toolHeight, _("Tool probe height"))
        self.addWidget(self.toolHeight)

        col += 1
        b = Button(lframe,
                   text=_("Calibrate"),
                   command=self.probe,
                   padx=2,
                   pady=1)
        b.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(
            b, _("Perform a calibration probing to determine the height"))
        self.addWidget(b)

        lframe.grid_columnconfigure(1, weight=1)
        lframe.grid_columnconfigure(2, weight=1)
        lframe.grid_columnconfigure(3, weight=1)

        self.loadConfig()
Beispiel #6
0
    def __init__(self, master, app):
        CNCRibbon.PageFrame.__init__(self, master, "Probe:Autolevel", app)

        lframe = LabelFrame(self, text="Autolevel", foreground="DarkBlue")
        lframe.pack(side=TOP, fill=X)

        row, col = 0, 0
        # Empty
        col += 1
        Label(lframe, text=_("Min")).grid(row=row, column=col, sticky=EW)
        col += 1
        Label(lframe, text=_("Max")).grid(row=row, column=col, sticky=EW)
        col += 1
        Label(lframe, text=_("Step")).grid(row=row, column=col, sticky=EW)
        col += 1
        Label(lframe, text="N").grid(row=row, column=col, sticky=EW)

        # --- X ---
        row += 1
        col = 0
        Label(lframe, text="X:").grid(row=row, column=col, sticky=E)
        col += 1
        self.probeXmin = tkExtra.FloatEntry(lframe,
                                            background="White",
                                            width=5)
        self.probeXmin.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeXmin, _("X minimum"))
        self.addWidget(self.probeXmin)

        col += 1
        self.probeXmax = tkExtra.FloatEntry(lframe,
                                            background="White",
                                            width=5)
        self.probeXmax.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeXmax, _("X maximum"))
        self.addWidget(self.probeXmax)

        col += 1
        self.probeXstep = Label(lframe,
                                foreground="DarkBlue",
                                background="gray95",
                                width=5)
        self.probeXstep.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeXstep, _("X step"))

        col += 1
        self.probeXbins = Spinbox(lframe,
                                  from_=2,
                                  to_=1000,
                                  command=self.draw,
                                  background="White",
                                  width=3)
        self.probeXbins.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeXbins, _("X bins"))
        self.addWidget(self.probeXbins)

        # --- Y ---
        row += 1
        col = 0
        Label(lframe, text="Y:").grid(row=row, column=col, sticky=E)
        col += 1
        self.probeYmin = tkExtra.FloatEntry(lframe,
                                            background="White",
                                            width=5)
        self.probeYmin.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeYmin, _("Y minimum"))
        self.addWidget(self.probeYmin)

        col += 1
        self.probeYmax = tkExtra.FloatEntry(lframe,
                                            background="White",
                                            width=5)
        self.probeYmax.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeYmax, _("Y maximum"))
        self.addWidget(self.probeYmax)

        col += 1
        self.probeYstep = Label(lframe,
                                foreground="DarkBlue",
                                background="gray95",
                                width=5)
        self.probeYstep.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeYstep, _("Y step"))

        col += 1
        self.probeYbins = Spinbox(lframe,
                                  from_=2,
                                  to_=1000,
                                  command=self.draw,
                                  background="White",
                                  width=3)
        self.probeYbins.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeYbins, _("Y bins"))
        self.addWidget(self.probeYbins)

        # Max Z
        row += 1
        col = 0

        Label(lframe, text="Z:").grid(row=row, column=col, sticky=E)
        col += 1
        self.probeZmin = tkExtra.FloatEntry(lframe,
                                            background="White",
                                            width=5)
        self.probeZmin.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeZmin, _("Z Minimum depth to scan"))
        self.addWidget(self.probeZmin)

        col += 1
        self.probeZmax = tkExtra.FloatEntry(lframe,
                                            background="White",
                                            width=5)
        self.probeZmax.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.probeZmax, _("Z safe to move"))
        self.addWidget(self.probeZmax)

        lframe.grid_columnconfigure(1, weight=2)
        lframe.grid_columnconfigure(2, weight=2)
        lframe.grid_columnconfigure(3, weight=1)

        self.loadConfig()
Beispiel #7
0
    def __init__(self, master, app):
        global wcsvar
        CNCRibbon.PageExLabelFrame.__init__(self, master, "State", app)
        self._gUpdate = False

        # State
        f = Frame(self())
        f.pack(side=TOP, fill=X)

        # ===
        col, row = 0, 0
        f2 = Frame(f)
        f2.grid(row=row, column=col, columnspan=5, sticky=EW)
        for p, w in enumerate(WCS):
            col += 1
            b = Radiobutton(f2,
                            text=w,
                            foreground="DarkRed",
                            font="Helvetica,14",
                            padx=1,
                            pady=1,
                            variable=wcsvar,
                            value=p,
                            indicatoron=FALSE,
                            activebackground="LightYellow",
                            command=self.wcsChange)
            b.pack(side=LEFT, fill=X, expand=YES)
            tkExtra.Balloon.set(b, _("Switch to workspace %s") % (w))
            self.addWidget(b)

        # Absolute or relative mode
        row += 1
        col = 0
        Label(f, text=_("Distance:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.distance = tkExtra.Combobox(f,
                                         True,
                                         command=self.distanceChange,
                                         width=5,
                                         background="White")
        self.distance.fill(sorted(DISTANCE_MODE.values()))
        self.distance.grid(row=row, column=col, columnspan=2, sticky=EW)
        tkExtra.Balloon.set(self.distance, _("Distance Mode [G90,G91]"))
        self.addWidget(self.distance)

        # populate gstate dictionary
        self.gstate = {}  # $G state results widget dictionary
        for k, v in DISTANCE_MODE.items():
            self.gstate[k] = (self.distance, v)

        # Units mode
        col += 2
        Label(f, text=_("Units:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.units = tkExtra.Combobox(f,
                                      True,
                                      command=self.unitsChange,
                                      width=5,
                                      background="White")
        self.units.fill(sorted(UNITS.values()))
        self.units.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.units, _("Units [G20, G21]"))
        for k, v in UNITS.items():
            self.gstate[k] = (self.units, v)
        self.addWidget(self.units)

        # Tool
        row += 1
        col = 0
        Label(f, text=_("Tool:")).grid(row=row, column=col, sticky=E)

        col += 1
        self.toolEntry = tkExtra.IntegerEntry(f, background="White", width=5)
        self.toolEntry.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.toolEntry, _("Tool number [T#]"))
        self.addWidget(self.toolEntry)

        col += 1
        b = Button(f, text=_("set"), command=self.setTool, padx=1, pady=1)
        b.grid(row=row, column=col, sticky=W)
        self.addWidget(b)

        # Plane
        col += 1
        Label(f, text=_("Plane:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.plane = tkExtra.Combobox(f,
                                      True,
                                      command=self.planeChange,
                                      width=5,
                                      background="White")
        self.plane.fill(sorted(PLANE.values()))
        self.plane.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.plane, _("Plane [G17,G18,G19]"))
        self.addWidget(self.plane)

        for k, v in PLANE.items():
            self.gstate[k] = (self.plane, v)

        # Feed mode
        row += 1
        col = 0
        Label(f, text=_("Feed:")).grid(row=row, column=col, sticky=E)

        col += 1
        self.feedRate = tkExtra.FloatEntry(f,
                                           background="White",
                                           disabledforeground="Black",
                                           width=5)
        self.feedRate.grid(row=row, column=col, sticky=EW)
        self.feedRate.bind('<Return>', self.setFeedRate)
        self.feedRate.bind('<KP_Enter>', self.setFeedRate)
        tkExtra.Balloon.set(self.feedRate, _("Feed Rate [F#]"))
        self.addWidget(self.feedRate)

        col += 1
        b = Button(f, text=_("set"), command=self.setFeedRate, padx=1, pady=1)
        b.grid(row=row, column=col, columnspan=2, sticky=W)
        self.addWidget(b)

        col += 1
        Label(f, text=_("Mode:")).grid(row=row, column=col, sticky=E)

        col += 1
        self.feedMode = tkExtra.Combobox(f,
                                         True,
                                         command=self.feedModeChange,
                                         width=5,
                                         background="White")
        self.feedMode.fill(sorted(FEED_MODE.values()))
        self.feedMode.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.feedMode, _("Feed Mode [G93, G94, G95]"))
        for k, v in FEED_MODE.items():
            self.gstate[k] = (self.feedMode, v)
        self.addWidget(self.feedMode)

        # ---
        f.grid_columnconfigure(1, weight=1)
        f.grid_columnconfigure(4, weight=1)

        # Spindle
        f = Frame(self())
        f.pack(side=BOTTOM, fill=X)

        self.override = IntVar()
        self.override.set(100)
        self.spindle = BooleanVar()
        self.spindleSpeed = IntVar()

        col, row = 0, 0
        self.overrideCombo = tkExtra.Combobox(f,
                                              width=8,
                                              command=self.overrideComboChange)
        self.overrideCombo.fill(OVERRIDES)
        self.overrideCombo.grid(row=row, column=col, pady=0, sticky=EW)
        tkExtra.Balloon.set(self.overrideCombo, _("Select override type."))

        b = Button(f, text=_("Reset"), pady=0, command=self.resetOverride)
        b.grid(row=row + 1, column=col, pady=0, sticky=NSEW)
        tkExtra.Balloon.set(b, _("Reset override to 100%"))

        col += 1
        self.overrideScale = Scale(f,
                                   command=self.overrideChange,
                                   variable=self.override,
                                   showvalue=True,
                                   orient=HORIZONTAL,
                                   from_=25,
                                   to_=200,
                                   resolution=1)
        self.overrideScale.bind("<Double-1>", self.resetOverride)
        self.overrideScale.bind("<Button-3>", self.resetOverride)
        self.overrideScale.grid(row=row,
                                column=col,
                                rowspan=2,
                                columnspan=4,
                                sticky=EW)
        tkExtra.Balloon.set(
            self.overrideScale,
            _("Set Feed/Rapid/Spindle Override. Right or Double click to reset."
              ))

        self.overrideCombo.set(OVERRIDES[0])

        # ---
        row += 2
        col = 0
        b = Checkbutton(f,
                        text=_("Spindle"),
                        image=Utils.icons["spinningtop"],
                        command=self.spindleControl,
                        compound=LEFT,
                        indicatoron=False,
                        variable=self.spindle,
                        padx=1,
                        pady=0)
        tkExtra.Balloon.set(b, _("Start/Stop spindle (M3/M5)"))
        b.grid(row=row, column=col, pady=0, sticky=NSEW)
        self.addWidget(b)

        col += 1
        b = Scale(f,
                  variable=self.spindleSpeed,
                  command=self.spindleControl,
                  showvalue=True,
                  orient=HORIZONTAL,
                  from_=Utils.config.get("CNC", "spindlemin"),
                  to_=Utils.config.get("CNC", "spindlemax"))
        tkExtra.Balloon.set(b, _("Set spindle RPM"))
        b.grid(row=row, column=col, sticky=EW, columnspan=3)
        self.addWidget(b)

        f.grid_columnconfigure(1, weight=1)

        # Coolant control

        self.coolant = BooleanVar()
        self.mist = BooleanVar()
        self.flood = BooleanVar()

        row += 1
        col = 0
        Label(f, text=_("Coolant:")).grid(row=row, column=col, sticky=E)
        col += 1

        coolantDisable = Checkbutton(f,
                                     text=_("OFF"),
                                     command=self.coolantOff,
                                     indicatoron=False,
                                     variable=self.coolant,
                                     padx=1,
                                     pady=0)
        tkExtra.Balloon.set(coolantDisable, _("Stop cooling (M9)"))
        coolantDisable.grid(row=row, column=col, pady=0, sticky=NSEW)
        self.addWidget(coolantDisable)

        col += 1
        floodEnable = Checkbutton(f,
                                  text=_("Flood"),
                                  command=self.coolantFlood,
                                  indicatoron=False,
                                  variable=self.flood,
                                  padx=1,
                                  pady=0)
        tkExtra.Balloon.set(floodEnable, _("Start flood (M8)"))
        floodEnable.grid(row=row, column=col, pady=0, sticky=NSEW)
        self.addWidget(floodEnable)

        col += 1
        mistEnable = Checkbutton(f,
                                 text=_("Mist"),
                                 command=self.coolantMist,
                                 indicatoron=False,
                                 variable=self.mist,
                                 padx=1,
                                 pady=0)
        tkExtra.Balloon.set(mistEnable, _("Start mist (M7)"))
        mistEnable.grid(row=row, column=col, pady=0, sticky=NSEW)
        self.addWidget(mistEnable)
        f.grid_columnconfigure(1, weight=1)
Beispiel #8
0
    def __init__(self, master, app):
        CNCRibbon.PageFrame.__init__(self, master, "DRO", app)

        DROFrame.dro_status = Utils.getFont("dro_status", DROFrame.dro_status)
        DROFrame.dro_wpos = Utils.getFont("dro_wpos", DROFrame.dro_wpos)
        DROFrame.dro_mpos = Utils.getFont("dro_mpos", DROFrame.dro_mpos)

        row = 0
        col = 0
        Label(self, text=_("Status:")).grid(row=row, column=col, sticky=E)
        col += 1
        self.state = Button(self,
                            text=Sender.NOT_CONNECTED,
                            font=DROFrame.dro_status,
                            command=self.showState,
                            cursor="hand1",
                            background=Sender.STATECOLOR[Sender.NOT_CONNECTED],
                            activebackground="LightYellow")
        self.state.grid(row=row, column=col, columnspan=3, sticky=EW)
        tkExtra.Balloon.set(
            self.state,
            _("Show current state of the machine\nClick to see details\nRight-Click to clear alarm/errors"
              ))
        #self.state.bind("<Button-3>", lambda e,s=self : s.event_generate("<<AlarmClear>>"))
        self.state.bind("<Button-3>", self.stateMenu)

        row += 1
        col = 0
        Label(self, text=_("WPos:")).grid(row=row, column=col, sticky=E)

        # work
        col += 1
        self.xwork = tkExtra.FloatEntry(self,
                                        font=DROFrame.dro_wpos,
                                        background="White",
                                        relief=FLAT,
                                        borderwidth=0,
                                        justify=RIGHT)
        self.xwork.grid(row=row, column=col, padx=1, sticky=EW)
        tkExtra.Balloon.set(self.xwork, _("X work position (click to set)"))
        self.xwork.bind('<FocusIn>', self.workFocus)
        self.xwork.bind('<Return>', self.setX)
        self.xwork.bind('<KP_Enter>', self.setX)

        # ---
        col += 1
        self.ywork = tkExtra.FloatEntry(self,
                                        font=DROFrame.dro_wpos,
                                        background="White",
                                        relief=FLAT,
                                        borderwidth=0,
                                        justify=RIGHT)
        self.ywork.grid(row=row, column=col, padx=1, sticky=EW)
        tkExtra.Balloon.set(self.ywork, _("Y work position (click to set)"))
        self.ywork.bind('<FocusIn>', self.workFocus)
        self.ywork.bind('<Return>', self.setY)
        self.ywork.bind('<KP_Enter>', self.setY)

        # ---
        col += 1
        self.zwork = tkExtra.FloatEntry(self,
                                        font=DROFrame.dro_wpos,
                                        background="White",
                                        relief=FLAT,
                                        borderwidth=0,
                                        justify=RIGHT)
        self.zwork.grid(row=row, column=col, padx=1, sticky=EW)
        tkExtra.Balloon.set(self.zwork, _("Z work position (click to set)"))
        self.zwork.bind('<FocusIn>', self.workFocus)
        self.zwork.bind('<Return>', self.setZ)
        self.zwork.bind('<KP_Enter>', self.setZ)

        # Machine
        row += 1
        col = 0
        Label(self, text=_("MPos:")).grid(row=row, column=col, sticky=E)

        col += 1
        self.xmachine = Label(self,
                              font=DROFrame.dro_mpos,
                              background="White",
                              anchor=E)
        self.xmachine.grid(row=row, column=col, padx=1, sticky=EW)

        col += 1
        self.ymachine = Label(self,
                              font=DROFrame.dro_mpos,
                              background="White",
                              anchor=E)
        self.ymachine.grid(row=row, column=col, padx=1, sticky=EW)

        col += 1
        self.zmachine = Label(self,
                              font=DROFrame.dro_mpos,
                              background="White",
                              anchor=E)
        self.zmachine.grid(row=row, column=col, padx=1, sticky=EW)

        # Set buttons
        row += 1
        col = 1

        self.xzero = Button(self,
                            text="X=0",
                            command=self.setX0,
                            activebackground="LightYellow",
                            padx=2,
                            pady=1)
        self.xzero.grid(row=row, column=col, pady=0, sticky=EW)
        tkExtra.Balloon.set(
            self.xzero,
            _("Set X coordinate to zero (or to typed coordinate in WPos)"))
        self.addWidget(self.xzero)

        col += 1
        self.yzero = Button(self,
                            text="Y=0",
                            command=self.setY0,
                            activebackground="LightYellow",
                            padx=2,
                            pady=1)
        self.yzero.grid(row=row, column=col, pady=0, sticky=EW)
        tkExtra.Balloon.set(
            self.yzero,
            _("Set Y coordinate to zero (or to typed coordinate in WPos)"))
        self.addWidget(self.yzero)

        col += 1
        self.zzero = Button(self,
                            text="Z=0",
                            command=self.setZ0,
                            activebackground="LightYellow",
                            padx=2,
                            pady=1)
        self.zzero.grid(row=row, column=col, pady=0, sticky=EW)
        tkExtra.Balloon.set(
            self.zzero,
            _("Set Z coordinate to zero (or to typed coordinate in WPos)"))
        self.addWidget(self.zzero)

        self.grid_columnconfigure(1, weight=1)
        self.grid_columnconfigure(2, weight=1)
        self.grid_columnconfigure(3, weight=1)
Beispiel #9
0
    def __init__(self, master, app):
        CNCRibbon.PageExLabelFrame.__init__(self, master, "State", _("State"),
                                            app)

        self._gUpdate = False

        # print("StateFrame self.app",self.app)

        # State
        frame = Tk.Frame(self())
        frame.pack(side=Tk.TOP, fill=Tk.X)

        col, row = 0, 0
        subframe = Tk.Frame(frame)
        subframe.grid(row=row, column=col, columnspan=5, sticky=Tk.EW)

        for p, w in enumerate(OCV.WCS):
            col += 1
            but = Tk.Radiobutton(subframe,
                                 text=w,
                                 foreground="DarkRed",
                                 font=OCV.FONT_STATE_WCS,
                                 padx=1,
                                 pady=1,
                                 variable=OCV.wcsvar,
                                 value=p,
                                 indicatoron=0,
                                 activebackground="LightYellow",
                                 command=self.wcsChange)

            but.pack(side=Tk.LEFT, fill=Tk.X, expand=Tk.YES)

            tkExtra.Balloon.set(but, _("Switch to workspace {0}").format(w))

            self.addWidget(but)

        row += 1

        label_text = (_("Distance:"), _("Units:"), _("Tool:"), _("Plane:"),
                      _("Feed:"), _("Mode:"), _("TLO:"), _("G92:"))
        label_pos = ((row, 0), (row, 3), (row + 1, 0), (row + 1, 3),
                     (row + 2, 0), (row + 2, 3), (row + 3, 0), (row + 3, 3))

        for idx, val in enumerate(label_text):
            lab = Tk.Label(frame,
                           text=label_text[idx],
                           font=OCV.FONT_STATE_BUT)

            lab.grid(row=label_pos[idx][0],
                     column=label_pos[idx][1],
                     sticky=Tk.E)

        # Absolute or relative mode
        col = 1

        self.distance = tkExtra.Combobox(
            frame,
            True,
            command=self.distanceChange,
            width=5,
            background=tkExtra.GLOBAL_CONTROL_BACKGROUND)

        self.distance.fill(sorted(OCV.DISTANCE_MODE.values()))
        self.distance.grid(row=row, column=col, columnspan=2, sticky=Tk.EW)

        bal_text = ""

        if OCV.IS_PY3 is True:
            g17_items = OCV.DISTANCE_MODE.items()
        else:
            g17_items = OCV.DISTANCE_MODE.viewitems()

        for key, val in g17_items:
            bal_text += "{0} > {1}\n".format(key, val)

        tkExtra.Balloon.set(self.distance,
                            _("Distance Mode:\n{0}".format(bal_text)))

        self.addWidget(self.distance)

        # populate gstate dictionary
        self.gstate = {}  # $G state results widget dictionary

        for key, val in g17_items:
            self.gstate[key] = (self.distance, val)

        col += 3

        self.units = tkExtra.Combobox(
            frame,
            True,
            command=self.unitsChange,
            width=5,
            background=tkExtra.GLOBAL_CONTROL_BACKGROUND)

        self.units.fill(sorted(OCV.UNITS.values()))
        self.units.grid(row=row, column=col, sticky=Tk.EW)

        bal_text = ""

        if OCV.IS_PY3 is True:
            unit_items = OCV.UNITS.items()
        else:
            unit_items = OCV.UNITS.viewitems()

        for key, val in unit_items:
            bal_text += "{0} > {1}\n".format(key, val)

        tkExtra.Balloon.set(self.units, _("Units:\n{0}".format(bal_text)))

        for key, val in unit_items:
            self.gstate[key] = (self.units, val)

        self.addWidget(self.units)

        # Tool
        row += 1
        col = 1
        self.toolEntry = tkExtra.IntegerEntry(
            frame, background=tkExtra.GLOBAL_CONTROL_BACKGROUND, width=5)

        self.toolEntry.grid(row=row, column=col, sticky=Tk.EW)

        tkExtra.Balloon.set(self.toolEntry, _("Tool number [T#]"))
        self.addWidget(self.toolEntry)

        col += 1

        but = Tk.Button(frame,
                        text=_("set"),
                        command=self.setTool,
                        padx=1,
                        pady=1)

        but.grid(row=row, column=col, sticky=Tk.W)
        self.addWidget(but)

        # Plane

        col += 2

        self.plane = tkExtra.Combobox(
            frame,
            True,
            command=self.planeChange,
            width=5,
            background=tkExtra.GLOBAL_CONTROL_BACKGROUND)

        self.plane.fill(sorted(OCV.PLANE.values()))
        self.plane.grid(row=row, column=col, sticky=Tk.EW)

        bal_text = ""

        if OCV.IS_PY3 is True:
            plane_items = OCV.PLANE.items()
        else:
            plane_items = OCV.PLANE.viewitems()

        for key, val in plane_items:
            bal_text += "{0} > {1}\n".format(key, val)

        tkExtra.Balloon.set(self.plane, _("Plane:\n{0}".format(bal_text)))

        self.addWidget(self.plane)

        for k, v in plane_items:
            self.gstate[k] = (self.plane, v)

        # Feed speed
        row += 1
        col = 1
        self.feed_rate = tkExtra.FloatEntry(
            frame,
            background=tkExtra.GLOBAL_CONTROL_BACKGROUND,
            disabledforeground="Black",
            width=5)

        self.feed_rate.grid(row=row, column=col, sticky=Tk.EW)
        self.feed_rate.bind('<Return>', self.setFeedRate)
        self.feed_rate.bind('<KP_Enter>', self.setFeedRate)

        tkExtra.Balloon.set(self.feed_rate, _("Feed Rate [F#]"))
        self.addWidget(self.feed_rate)

        col += 1

        but = Tk.Button(frame,
                        text=_("set"),
                        command=self.setFeedRate,
                        padx=1,
                        pady=1)

        but.grid(row=row, column=col, columnspan=2, sticky=Tk.W)
        self.addWidget(but)

        # Feed mode
        col += 2
        self.feedMode = tkExtra.Combobox(
            frame,
            True,
            command=self.feedModeChange,
            width=5,
            background=tkExtra.GLOBAL_CONTROL_BACKGROUND)

        self.feedMode.fill(sorted(OCV.FEED_MODE.values()))
        self.feedMode.grid(row=row, column=col, sticky=Tk.EW)

        bal_text = ""

        if OCV.IS_PY3 is True:
            feed_items = OCV.FEED_MODE.items()
        else:
            feed_items = OCV.FEED_MODE.viewitems()

        for key, val in feed_items:
            bal_text += "{0} > {1}\n".format(key, val)

        tkExtra.Balloon.set(self.feedMode,
                            _("Feed Mode:\n{0}".format(bal_text)))

        for key, val in feed_items:
            self.gstate[key] = (self.feedMode, val)

        self.addWidget(self.feedMode)

        # TLO
        row += 1
        col = 1

        self.tlo = tkExtra.FloatEntry(
            frame,
            background=tkExtra.GLOBAL_CONTROL_BACKGROUND,
            disabledforeground="Black",
            width=5)

        self.tlo.grid(row=row, column=col, sticky=Tk.EW)
        self.tlo.bind('<Return>', self.setTLO)
        self.tlo.bind('<KP_Enter>', self.setTLO)
        tkExtra.Balloon.set(self.tlo, _("Tool length offset [G43.1#]"))
        self.addWidget(self.tlo)

        col += 1

        but = Tk.Button(frame,
                        text=_("set"),
                        command=self.setTLO,
                        padx=1,
                        pady=1)

        but.grid(row=row, column=col, columnspan=2, sticky=Tk.W)
        self.addWidget(but)

        # g92
        col += 2

        self.g92 = Tk.Label(frame, text="")

        self.g92.grid(row=row, column=col, columnspan=3, sticky=Tk.EW)

        tkExtra.Balloon.set(self.g92, _("Set position [G92 X# Y# Z#]"))
        self.addWidget(self.g92)

        frame.grid_columnconfigure(1, weight=1)
        frame.grid_columnconfigure(4, weight=1)

        # Spindle
        frame1 = Tk.Frame(self())
        frame1.pack(side=Tk.BOTTOM, fill=Tk.X)

        self.override = Tk.IntVar()
        self.override.set(100)
        self.spindle = Tk.BooleanVar()
        self.spindleSpeed = Tk.IntVar()

        col, row = 0, 0

        self.overrideCombo = tkExtra.Combobox(frame1,
                                              width=8,
                                              command=self.overrideComboChange)

        self.overrideCombo.fill(OVERRIDES)
        self.overrideCombo.grid(row=row, column=col, pady=0, sticky=Tk.EW)

        tkExtra.Balloon.set(self.overrideCombo, _("Select override type."))

        but = Tk.Button(frame1,
                        text=_("Reset"),
                        pady=0,
                        command=self.resetOverride)

        but.grid(row=row + 1, column=col, pady=0, sticky=Tk.NSEW)

        tkExtra.Balloon.set(but, _("Reset override to 100%"))

        col += 1

        self.overrideScale = Tk.Scale(frame1,
                                      command=self.overrideChange,
                                      variable=self.override,
                                      showvalue=True,
                                      orient=Tk.HORIZONTAL,
                                      from_=25,
                                      to_=200,
                                      resolution=1)

        self.overrideScale.bind("<Double-1>", self.resetOverride)
        self.overrideScale.bind("<Button-3>", self.resetOverride)

        self.overrideScale.grid(row=row,
                                column=col,
                                rowspan=2,
                                columnspan=4,
                                sticky=Tk.EW)
        tkExtra.Balloon.set(
            self.overrideScale,
            _("Set Feed/Rapid/Spindle Override. Right or Double click to reset."
              ))

        self.overrideCombo.set(OVERRIDES[0])

        row += 2
        col = 0

        but = Tk.Checkbutton(frame1,
                             text=_("Spindle"),
                             image=OCV.icons["spinningtop"],
                             command=self.spindleControl,
                             compound=Tk.LEFT,
                             indicatoron=0,
                             variable=self.spindle,
                             padx=1,
                             pady=0)

        tkExtra.Balloon.set(but, _("Start/Stop spindle (M3/M5)"))

        but.grid(row=row, column=col, pady=0, sticky=Tk.NSEW)
        self.addWidget(but)

        col += 1
        but = Tk.Scale(frame1,
                       variable=self.spindleSpeed,
                       command=self.spindleControl,
                       showvalue=True,
                       orient=Tk.HORIZONTAL,
                       from_=OCV.config.get("CNC", "spindlemin"),
                       to_=OCV.config.get("CNC", "spindlemax"))

        tkExtra.Balloon.set(but, _("Set spindle RPM"))
        but.grid(row=row, column=col, sticky=Tk.EW, columnspan=3)
        self.addWidget(but)

        frame1.grid_columnconfigure(1, weight=1)

        # Coolant control
        self.coolant = Tk.BooleanVar()
        self.mist = Tk.BooleanVar()
        self.flood = Tk.BooleanVar()

        row += 1
        col = 0
        Tk.Label(frame1, text=_("Coolant:")).grid(row=row,
                                                  column=col,
                                                  sticky=Tk.E)

        col += 1

        coolantDisable = Tk.Checkbutton(frame1,
                                        text=_("OFF"),
                                        command=self.coolantOff,
                                        indicatoron=0,
                                        variable=self.coolant,
                                        padx=1,
                                        pady=0)

        tkExtra.Balloon.set(coolantDisable, _("Stop cooling (M9)"))
        coolantDisable.grid(row=row, column=col, pady=0, sticky=Tk.NSEW)
        self.addWidget(coolantDisable)

        col += 1

        floodEnable = Tk.Checkbutton(frame1,
                                     text=_("Flood"),
                                     command=self.coolantFlood,
                                     indicatoron=0,
                                     variable=self.flood,
                                     padx=1,
                                     pady=0)

        tkExtra.Balloon.set(floodEnable, _("Start flood (M8)"))
        floodEnable.grid(row=row, column=col, pady=0, sticky=Tk.NSEW)
        self.addWidget(floodEnable)

        col += 1

        mistEnable = Tk.Checkbutton(frame1,
                                    text=_("Mist"),
                                    command=self.coolantMist,
                                    indicatoron=0,
                                    variable=self.mist,
                                    padx=1,
                                    pady=0)

        tkExtra.Balloon.set(mistEnable, _("Start mist (M7)"))
        mistEnable.grid(row=row, column=col, pady=0, sticky=Tk.NSEW)
        self.addWidget(mistEnable)

        frame1.grid_columnconfigure(1, weight=1)
Beispiel #10
0
    def __init__(self, master, app):
        CNCRibbon.PageLabelFrame.__init__(self, master, "Engraving", app)
        self.clearanceZ = DoubleVar()
        self.retractZ = DoubleVar()
        self.depth = DoubleVar()
        # populate gstate dictionary
        self.gstate = {}  # $G state results widget dictionary
        #for k,v in DISTANCE_MODE.items():
        #    self.gstate[k] = (self.distance, v)

        # ---feedrate
        col, row = 0, 0
        b = Label(self, text=_("Feed Rate:"))
        b.grid(row=row, column=col, sticky=E)
        self.addWidget(b)

        col += 1
        self.feedrateentry = tkExtra.FloatEntry(self,
                                                background="White",
                                                width=20)
        self.feedrateentry.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.feedrateentry,
                            _("How Fast Tool moves while cutting"))
        #self.feedrateentry.set(CNC.vars["cutfeed"])
        self.feedrateentry.set(Utils.getFloat("Engraving", 'cutrate'))
        self.addWidget(self.feedrateentry)
        #TODO
        #for k,v in FEED_MODE.items(): self.gstate[k] = (self.feedMode, v)
        b = Label(self, text=_("mm/min"))
        b.grid(row=row, column=col + 1, sticky=E)
        self.addWidget(b)

        # ---plungerate
        col = 0
        row += 1
        b = Label(self, text=_("Plunge Rate:"))
        b.grid(row=row, column=col, sticky=E)
        self.addWidget(b)

        col += 1
        self.plungerateentry = tkExtra.FloatEntry(self,
                                                  background="White",
                                                  width=20)
        self.plungerateentry.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.plungerateentry,
                            _("How Fast Tool moves when plunging"))
        #self.plungerateentry.set(CNC.vars["cutfeedz"])
        self.plungerateentry.set(Utils.getFloat("Engraving", 'plungerate'))
        self.addWidget(self.plungerateentry)
        #TODO
        #for k,v in FEED_MODE.items(): self.gstate[k] = (self.feedMode, v)
        b = Label(self, text=_("mm/min"))
        b.grid(row=row, column=col + 1, sticky=E)
        self.addWidget(b)

        # ---clearanceZ
        col = 0
        row += 1
        b = Label(self, text=_("Clearance Height:"))
        b.grid(row=row, column=col, sticky=E)
        self.addWidget(b)

        col += 1
        self.clearanceZentry = tkExtra.FloatEntry(self,
                                                  background="White",
                                                  width=10,
                                                  textvariable=self.clearanceZ)
        self.clearanceZentry.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.clearanceZentry,
                            _("Height above tag between letters"))
        self.clearanceZentry.set(Utils.getFloat("Engraving", 'clearance'))
        self.addWidget(self.clearanceZentry)
        #TODO
        #for k,v in FEED_MODE.items(): self.gstate[k] = (self.feedMode, v)
        b = Label(self, text=_("mm"))
        b.grid(row=row, column=col + 1, sticky=E)
        self.addWidget(b)

        # ---retractZ
        col = 0
        row += 1
        b = Label(self, text=_("Retract Height:"))
        b.grid(row=row, column=col, sticky=E)
        self.addWidget(b)

        col += 1
        self.retractZentry = tkExtra.FloatEntry(self,
                                                background="White",
                                                width=5,
                                                textvariable=self.retractZ)
        self.retractZentry.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.retractZentry, _("Height above between Tags"))
        self.retractZentry.set(Utils.getFloat("Engraving", 'retract'))
        self.addWidget(self.retractZentry)
        #TODO
        #for k,v in FEED_MODE.items(): self.gstate[k] = (self.feedMode, v)
        b = Label(self, text=_("mm"))
        b.grid(row=row, column=col + 1, sticky=E)
        self.addWidget(b)

        # ---Engraving Depth
        col = 0
        row += 1
        b = Label(self, text=_("Depth:"))
        b.grid(row=row, column=col, sticky=E)
        self.addWidget(b)

        col += 1
        self.depth = tkExtra.FloatEntry(self,
                                        background="White",
                                        width=5,
                                        textvariable=self.depth)
        self.depth.grid(row=row, column=col, sticky=EW)
        tkExtra.Balloon.set(self.depth, _("How Far to carve into piece"))
        self.depth.set(Utils.getFloat("Engraving", 'depth'))
        self.addWidget(self.depth)
        #TODO
        #for k,v in FEED_MODE.items(): self.gstate[k] = (self.feedMode, v)
        b = Label(self, text=_("mm"))
        b.grid(row=row, column=col + 1, sticky=E)
        self.addWidget(b)
Beispiel #11
0
	def __init__(self, master, app):
		CNCRibbon.PageFrame.__init__(self, master, "Probe:Probe", app)

		#----------------------------------------------------------------
		# Single probe
		#----------------------------------------------------------------
		lframe = tkExtra.ExLabelFrame(self, text=_("Probe"), foreground="DarkBlue")
		lframe.pack(side=TOP, fill=X)

		row,col = 0,0
		Label(lframe(), text=_("Probe:")).grid(row=row, column=col, sticky=E)

		col += 1
		self._probeX = Label(lframe(), foreground="DarkBlue", background="gray90")
		self._probeX.grid(row=row, column=col, padx=1, sticky=EW+S)

		col += 1
		self._probeY = Label(lframe(), foreground="DarkBlue", background="gray90")
		self._probeY.grid(row=row, column=col, padx=1, sticky=EW+S)

		col += 1
		self._probeZ = Label(lframe(), foreground="DarkBlue", background="gray90")
		self._probeZ.grid(row=row, column=col, padx=1, sticky=EW+S)

		# ---
		col += 1
		b = Button(lframe(), #"<<Probe>>",
				image=Utils.icons["probe32"],
				text=_("Probe"),
				compound=TOP,
				command=self.probe)
		b.grid(row=row, column=col, rowspan=2, padx=1, sticky=EW+S)
		self.addWidget(b)
		tkExtra.Balloon.set(b, _("Perform a single probe cycle"))

		# ---
		row,col = row+1,0
		Label(lframe(), text=_("Pos:")).grid(row=row, column=col, sticky=E)

		col += 1
		self.probeXdir = tkExtra.FloatEntry(lframe(), background="White")
		self.probeXdir.grid(row=row, column=col, sticky=EW+S)
		tkExtra.Balloon.set(self.probeXdir, _("Probe along X direction"))
		self.addWidget(self.probeXdir)

		col += 1
		self.probeYdir = tkExtra.FloatEntry(lframe(), background="White")
		self.probeYdir.grid(row=row, column=col, sticky=EW+S)
		tkExtra.Balloon.set(self.probeYdir, _("Probe along Y direction"))
		self.addWidget(self.probeYdir)

		col += 1
		self.probeZdir = tkExtra.FloatEntry(lframe(), background="White")
		self.probeZdir.grid(row=row, column=col, sticky=EW+S)
		tkExtra.Balloon.set(self.probeZdir, _("Probe along Z direction"))
		self.addWidget(self.probeZdir)

		lframe().grid_columnconfigure(1,weight=1)
		lframe().grid_columnconfigure(2,weight=1)
		lframe().grid_columnconfigure(3,weight=1)

		#----------------------------------------------------------------
		# Center probing
		#----------------------------------------------------------------
		lframe = tkExtra.ExLabelFrame(self, text=_("Center"), foreground="DarkBlue")
		lframe.pack(side=TOP, expand=YES, fill=X)

		Label(lframe(), text=_("Diameter:")).pack(side=LEFT)
		self.diameter = tkExtra.FloatEntry(lframe(), background="White")
		self.diameter.pack(side=LEFT, expand=YES, fill=X)
		tkExtra.Balloon.set(self.diameter, _("Probing ring internal diameter"))
		self.addWidget(self.diameter)

		# ---
		b = Button(lframe(),
				image=Utils.icons["target32"],
				text=_("Center"),
				compound=TOP,
				command=self.probeCenter)
		b.pack(side=RIGHT)
		self.addWidget(b)
		tkExtra.Balloon.set(b, _("Center probing using a ring"))

		#----------------------------------------------------------------
		# Align / Orient / Square ?
		#----------------------------------------------------------------
		lframe = tkExtra.ExLabelFrame(self, text=_("Orient"), foreground="DarkBlue")
		lframe.pack(side=TOP, expand=YES, fill=X)

		# ---
		row, col = 0,0

		Label(lframe(), text=_("Markers:")).grid(row=row, column=col, sticky=E)
		col += 1

		self.scale_orient = Scale(lframe(),
					from_=0, to_=0,
					orient=HORIZONTAL,
					showvalue=1,
					state=DISABLED,
					command=self.changeMarker)
		self.scale_orient.grid(row=row, column=col, columnspan=2, sticky=EW)
		tkExtra.Balloon.set(self.scale_orient, _("Select orientation marker"))

		# Add new point
		col += 2
		b = Button(lframe(), text=_("Add"),
				image=Utils.icons["add"],
				compound=LEFT,
				command=lambda s=self: s.event_generate("<<AddMarker>>"),
				padx = 1,
				pady = 1)
		b.grid(row=row, column=col, sticky=NSEW)
		self.addWidget(b)
		tkExtra.Balloon.set(b, _("Add an orientation marker. " \
				"Jog first the machine to the marker position " \
				"and then click on canvas to add the marker."))

		# ----
		row += 1
		col = 0
		Label(lframe(), text="Gcode:").grid(row=row, column=col, sticky=E)
		col += 1
		self.x_orient = tkExtra.FloatEntry(lframe(), background="White")
		self.x_orient.grid(row=row, column=col, sticky=EW)
		self.x_orient.bind("<FocusOut>", self.orientUpdate)
		self.x_orient.bind("<Return>",   self.orientUpdate)
		self.x_orient.bind("<KP_Enter>", self.orientUpdate)
		tkExtra.Balloon.set(self.x_orient, _("GCode X coordinate of orientation point"))

		col += 1
		self.y_orient = tkExtra.FloatEntry(lframe(), background="White")
		self.y_orient.grid(row=row, column=col, sticky=EW)
		self.y_orient.bind("<FocusOut>", self.orientUpdate)
		self.y_orient.bind("<Return>",   self.orientUpdate)
		self.y_orient.bind("<KP_Enter>", self.orientUpdate)
		tkExtra.Balloon.set(self.y_orient, _("GCode Y coordinate of orientation point"))

		# Buttons
		col += 1
		b = Button(lframe(), text=_("Delete"),
				image=Utils.icons["x"],
				compound=LEFT,
				command = self.orientDelete,
				padx = 1,
				pady = 1)
		b.grid(row=row, column=col, sticky=EW)
		self.addWidget(b)
		tkExtra.Balloon.set(b, _("Delete current marker"))

		# ---
		row += 1
		col = 0

		Label(lframe(), text="WPos:").grid(row=row, column=col, sticky=E)
		col += 1
		self.xm_orient = tkExtra.FloatEntry(lframe(), background="White")
		self.xm_orient.grid(row=row, column=col, sticky=EW)
		self.xm_orient.bind("<FocusOut>", self.orientUpdate)
		self.xm_orient.bind("<Return>",   self.orientUpdate)
		self.xm_orient.bind("<KP_Enter>", self.orientUpdate)
		tkExtra.Balloon.set(self.xm_orient, _("Machine X coordinate of orientation point"))

		col += 1
		self.ym_orient = tkExtra.FloatEntry(lframe(), background="White")
		self.ym_orient.grid(row=row, column=col, sticky=EW)
		self.ym_orient.bind("<FocusOut>", self.orientUpdate)
		self.ym_orient.bind("<Return>",   self.orientUpdate)
		self.ym_orient.bind("<KP_Enter>", self.orientUpdate)
		tkExtra.Balloon.set(self.ym_orient, _("Machine Y coordinate of orientation point"))

		# Buttons
		col += 1
		b = Button(lframe(), text=_("Clear"),
				image=Utils.icons["clear"],
				compound=LEFT,
				command = self.orientClear,
				padx = 1,
				pady = 1)
		b.grid(row=row, column=col, sticky=EW)
		self.addWidget(b)
		tkExtra.Balloon.set(b, _("Delete all markers"))

		# ---
		row += 1
		col = 0
		Label(lframe(), text=_("Angle:")).grid(row=row, column=col, sticky=E)

		col += 1
		self.angle_orient = Label(lframe(), foreground="DarkBlue", background="gray90", anchor=W)
		self.angle_orient.grid(row=row, column=col, columnspan=2, sticky=EW, padx=1, pady=1)

		# Buttons
		col += 2
		b = Button(lframe(), text=_("Orient"),
				image=Utils.icons["setsquare32"],
				compound=TOP,
				command = lambda a=app:a.insertCommand("ORIENT",True),
				padx = 1,
				pady = 1)
		b.grid(row=row, rowspan=3, column=col, sticky=EW)
		self.addWidget(b)
		tkExtra.Balloon.set(b, _("Align GCode with the machine markers"))

		# ---
		row += 1
		col = 0
		Label(lframe(), text=_("Offset:")).grid(row=row, column=col, sticky=E)

		col += 1
		self.xo_orient = Label(lframe(), foreground="DarkBlue", background="gray90", anchor=W)
		self.xo_orient.grid(row=row, column=col, sticky=EW, padx=1)

		col += 1
		self.yo_orient = Label(lframe(), foreground="DarkBlue", background="gray90", anchor=W)
		self.yo_orient.grid(row=row, column=col, sticky=EW, padx=1)

		# ---
		row += 1
		col = 0
		Label(lframe(), text=_("Error:")).grid(row=row, column=col, sticky=E)
		col += 1
		self.err_orient = Label(lframe(), foreground="DarkBlue", background="gray90", anchor=W)
		self.err_orient.grid(row=row, column=col, columnspan=2, sticky=EW, padx=1, pady=1)

		lframe().grid_columnconfigure(1, weight=1)
		lframe().grid_columnconfigure(2, weight=1)

		#----------------------------------------------------------------
		self.warn = True
		self.loadConfig()