#!/usr/bin/env python
# -*- coding: utf-8 -*-
# ------------------------------ 
#         CZOP WAŁU Z FAZAMI
# ------------------------------ 
# 
# Z. Maciej "Miki" Bajkowski <admin@wiarus.org>
# Time-stamp: <2012-01-08 13:55> 
import sys, os
BASE = os.environ['EMC2_HOME']
sys.path.insert(0, os.path.join(BASE, "lib", "python"))

import math

def _(s): return s

def ui():
    import Tkinter
    import pickle
    import nf
    import rs274.options
    import os

    app = Tkinter.Tk()
    rs274.options.install(app)
    app.tk.call("source", os.path.join(BASE, "share", "axis", "tcl", "combobox.tcl"))

    app.wm_title(_("Czop walca"))
    app.wm_iconname(_("Czop walca"))

    prev = Tkinter.Canvas(app, width=200, height=200)
    f = Tkinter.Frame(app)
    b = Tkinter.Frame(app)
    prev.grid(row=0, column=0, sticky="nw")
    f.grid(row=0, column=1, sticky="nw")
    b.grid(row=1, column=0, columnspan=2, sticky="ne")

    validate_float    = "expr {[regexp {^-?([0-9]+(\.[0-9]*)?|\.[0-9]+|)$} %P]}"
    validate_int      = "expr {[regexp {^-?([0-9]+|)$} %P]}"
    validate_posfloat = "expr {[regexp {^?([0-9]+(\.[0-9]*)?|\.[0-9]+|)$} %P]}"
    validate_posint   = "expr {[regexp {^([0-9]+|)$} %P]}"
    def posfloatentry(f, v):
        var = Tkinter.DoubleVar(f)
        var.set(v)
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_posfloat, validate="all", width=10)
        return w, var

    def floatentry(f, v):
        var = Tkinter.DoubleVar(f)
        var.set(v)
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_float, validate="all", width=10)
        return w, var

    def posintentry(f, v):
        var = Tkinter.IntVar(f)
        var.set(v)
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_posint, validate="all", width=10)
        return w, var


    def intentry(f, v):
        var = Tkinter.IntVar(f)
        var.set(v)
        w = Tkinter.Entry(f, textvariable=var, validatecommand=validate_int, validate="all", width=10)
        return w, var

    def checkbutton(k, v):
        var = Tkinter.BooleanVar(f)
        var.set(v)
        g = Tkinter.Frame(f)
        w = Tkinter.Checkbutton(g, variable=var, text="Yes")
        w.pack(side="left")
        return g, var 

    def intscale(k, v, min=1, max = 100):
        var = Tkinter.IntVar(f)
        var.set(v)
        g = Tkinter.Frame(f, borderwidth=0)
        w = Tkinter.Scale(g, orient="h", variable=var, from_=min, to=max, showvalue=False)
        l = Tkinter.Label(g, textvariable=var, width=3)
        l.pack(side="left")
        w.pack(side="left", fill="x", expand=1)
        return g, var

    def optionmenu(k, v, *options):
        options = list(options)
        def trace(*args):
            try:
                var.set(options.index(svar.get()))
            except ValueError:
                pass

        try:
            opt = options[v]
        except (TypeError, IndexError):
            v = 0
            opt = options[0]

        var = Tkinter.IntVar(f)    
        var.set(v)
        svar = Tkinter.StringVar(f)
        svar.set(options[v])
        svar.trace("w", trace)
        wp = f._w.rstrip(".") + ".c" + svar._name
        f.tk.call("combobox::combobox", wp, "-editable", 0, "-width",
                max(len(opt) for opt in options)+3, "-textvariable", svar._name,
                "-background", "white")
        f.tk.call(wp, "list", "insert", "end", *options)
        w = nf.makewidget(f, Tkinter.Widget, wp)
        return w, var

    rc = os.path.expanduser("~/.emc_czop")
# Poniżej deklarujemy wszystkie zmienne - ważna jest kolejność.
    constructors = [
        ("units", lambda f, v: optionmenu(f, v, _("G21 (mm)"), _("G20 (cal)"))),
        ("cx", floatentry),
        ("cz", floatentry),
	("dc", floatentry),
	("sw", floatentry),
	("fps", floatentry),
	("fpg", floatentry),
	("fds", floatentry),
	("fdg", floatentry)
    ]

    defaults = dict(
	cx = 0,
	cz = 0,
	dc = 0,
	sw = 0,
	fps = 0,
	fpg = 0,
	fds = 0,
	fdg = 0
    )

    texts = dict(
        units=_("Jednostki"),
	cx=_("Przybranie materiału"),
	cz=_("Średnica czopa"),
	dc=_("Długość czopa"),
	sw=_("Średnica wału"),
	fps=_("Szerokść fazy czopa (0=brak tej fazy)"),
	fpg=_("Wysokość fazy czopa"),
	fds=_("Szerokość fazy reszty wału (0=brak tej fazy)"),
	fdg=_("Wysokość fazy reszty wału")
    )

    try:
        defaults.update(pickle.load(open(rc, "rb")))
    except (IOError, pickle.PickleError): pass

    vars = {}
    widgets = {}
    for j, (k, con) in enumerate(constructors):
        v = defaults[k]
        text = texts.get(k, k.replace("_", " "))
        lab = Tkinter.Label(f, text=text)
        widgets[k], vars[k] = con(f, v)
        lab.grid(row=j, column=0, sticky="w")
        widgets[k].grid(row=j, column=1, sticky="ew")



    status = Tkinter.IntVar()
    bb = Tkinter.Button(b, text=_("OK"), command=lambda:status.set(1), width=8, default="active")
    bb.pack(side="left", padx=4, pady=4)
    bc = Tkinter.Button(b, text=_("Cancel"), command=lambda:status.set(-1), width=8, default="normal")
    bc.pack(side="left", padx=4, pady=4)
    
    app.bind("<Escape>", lambda evt: bc.invoke())
    app.bind("<Return>", lambda evt: bb.invoke())
    app.wm_protocol("WM_DELETE_WINDOW", lambda: bc.invoke())
    app.wm_resizable(0,0)

    app.wait_visibility()
    app.tk.call("after", "idle", ("after", "idle", "focus [tk_focusNext .]"))
    #app.tk_focusNext().focus()
    app.wait_variable(status)

    if status.get() == -1:
	raise SystemExit(1)

    for k, v in vars.items():
        defaults[k] = v.get()

    app.destroy()

    pickle.dump(defaults, open(rc, "wb"))

    return defaults

unitcodes = ['G21', 'G20']
u = ui()
print unitcodes[u['units']]


#definiwanie zmiennych - tu wpisujemy wszystkie wcześniej zadeklarowane zmienne.
cx = u['cx']
cz = u['cz']
dc = u['dc']
sw = u['sw']
fps = u['fps']
fpg = u['fpg']
fds = u['fds']
fdg = u['fdg']
#niżej wstawiamy kod .z ngc podstawiając pod potrzebne zmienne dane z tabelki w kolejności jak wpisane w nią
print """
            
(---------------------)            
(------ C Z O P ------)
(---------------------)
#<przybranie_materialu> = % 4.2f (tyle zbieramy ze srednicy na jeden raz, roznica srednic musi byc przez to podzielna)
#<srednica_czopu> = % 4.2f
#<dlugosc_czopu> = % 4.2f
#<srednica_walka> = % 4.2f   
#<szerokosc_fazki_czopu> = % 4.2f       (ustawienie zerowej szerokosci wylacza wykonywanie fazki)
#<glebokosc_fazki_czopu> = % 4.2f
#<szerokosc_fazki_walka> = % 4.2f      (ustawienie zerowej szerokosci wylacza wykonywanie fazki)
#<glebokosc_fazki_walka> = % 4.2f

(----------------------)
(----koniec ustawień---)

#<baza_x> = [#<srednica_walka> + 20]   (tu zjedzie w osi x noz po pracy, ustawic tyle, by mozna swobodnie zmierzyc, czy wyjac material)
#<srednica_walka_do_fazki> = #<srednica_walka> (zmienna #<srednica_walka> zmniejsza sie w trakcie wykonywania programu, zapamietuje ja wiec w zmiennej do pozniejszego fazowania)
#<szybkosc_posuwu> = 100            (Szybkosc posuwu w trakcie toczenia)
#<obroty_wrzeciona> = 1000


G0 z0.5 x#<baza_x> (Gdzie by noz nie był, zjeżdżamy do bazy w osi x - odpowiednio daleko od materiału, w osi z pol mm od jego poczatku)

M3 s#<obroty_wrzeciona> (wlaczamy wrzeciono)

o100 while [#<srednica_walka> gt #<srednica_czopu>] ( wykonuj dopoki #<srednica_walka> wiekszy od #<srednica_czopu> )
#<srednica_walka>=[#<srednica_walka>-#<przybranie_materialu>] ( deklarowane zmniejszenie)
G0 x#<srednica_walka> (ustawienie noza na pozycji )
g1 z-#<dlugosc_czopu> f#<szybkosc_posuwu> ( toczenie )
G0 x[#<srednica_walka>+1] ( odjazd od materialu)
z0.5 ( powrot na poczatek i wykonywanie ponowne )
o100 endwhile ( koniec toczenia )

o110 if [#<szerokosc_fazki_czopu> gt 0] (procedura wykonania fazki na wytoczonym czopie, wykonywana tylko, gdy zadeklarowana szerokość fazki jest większa od zera)       
    
x[#<srednica_czopu>-#<glebokosc_fazki_czopu>]             ( wjazd do fazki na fi #<srednica_czopu>)
g1 x[#<srednica_czopu>+0.5] z-[#<szerokosc_fazki_czopu>]    ( toczenie fazki na fi #<srednica_czopu>)

o110 endif (koniec procedury fazowania krawędzi czopa)


o120 if [#<szerokosc_fazki_walka> gt 0]  (procedura wykonania fazki na pozostałej krawędzi wałka, wykonywana tylko, gdy zadeklarowana szerokość fazki jest większa od zera)   
    
g0 z-[#<dlugosc_czopu>-0.5] x[#<srednica_walka_do_fazki> - #<glebokosc_fazki_walka>] ( dojazd do fazki na fi #<srednica_walka_do_fazki>)
g1 x[#<srednica_walka_do_fazki>+0.5] z-[#<dlugosc_czopu>+#<szerokosc_fazki_walka>] ( toczenie fazki na fi #<srednica_walka_do_fazki>)

o120 endif (koniec procedury fazowania pozostałej krawędzi wałka)

G0 z0.5
x#<baza_x> (zjazd do bazy)

    """ % (cx, cz, dc, sw, fps, fpg, fds, fdg) # tu trzeba również wpisać wszystkie zadeklarowane wcześniej zmienne w kolejności deklarowania. 

print "M30"
print "%"