flatcam/cirkuix.py

import threading
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GLib

from matplotlib.figure import Figure
from numpy import arange, sin, pi
from matplotlib.backends.backend_gtk3agg import FigureCanvasGTK3Agg as FigureCanvas
#from matplotlib.backends.backend_gtk3cairo import FigureCanvasGTK3Cairo as FigureCanvas
#from matplotlib.backends.backend_cairo import FigureCanvasCairo as FigureCanvas

from camlib import *


class CirkuixObj:
    form_getters = {}

    form_setters = {}

    # Instance of the application to which these are related.
    # The app should set this value.
    # TODO: Move the definitions of form_getters and form_setters
    # TODO: to their respective classes and use app to reference
    # TODO: the builder.
    app = None

    def __init__(self, name):
        self.name = name
        self.axes = None  # Matplotlib axes
        self.options = {}

    def setup_axes(self, figure):
        if self.axes is None:
            self.axes = figure.add_axes([0.05, 0.05, 0.9, 0.9], label=self.name)
        elif self.axes not in figure.axes:
            figure.add_axes(self.axes)

        self.axes.patch.set_visible(False)  # No background
        self.axes.set_aspect(1)

        return self.axes

    def set_options(self, options):
        for name in options:
            self.options[name] = options[name]
        return

    def to_form(self):
        for name in self.options:
            if name in self.form_setters:
                self.form_setters[name](self.options[name])

    def read_form(self):
        for name in self.form_getters:
            self.options[name] = self.form_getters[name]()


class CirkuixGerber(CirkuixObj, Gerber):

    def __init__(self, name):
        Gerber.__init__(self)
        CirkuixObj.__init__(self, name)

        self.options = {
            "plot": True,
            "mergepolys": True,
            "multicolored": False,
            "solid": False,
            "isotooldia": 0.4/25.4,
            "cutoutmargin": 0.2,
            "cutoutgapsize": 0.15,
            "gaps": "tb",
            "noncoppermargin": 0.0
        }

    def build_ui(self):
        print "cirkuixgerber.build_ui()"
        osw = self.app.builder.get_object("offscrwindow_gerber")
        #box1 = self.app.builder.get_object("box_gerber")
        #osw.remove(box1)
        sw = self.app.builder.get_object("sw_gerber")
        osw.remove(sw)
        vp = self.app.builder.get_object("vp_gerber")
        vp.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(1, 1, 1, 1))
        self.app.notebook.append_page(sw, Gtk.Label("Selection"))
        entry_name = self.app.builder.get_object("entry_gerbername")
        entry_name.set_text(self.name)
        entry_name.connect("activate", self.app.on_activate_name)
        self.to_form()
        sw.show()

    def plot(self, figure):
        self.setup_axes(figure)

        self.create_geometry()

        geometry = None
        if self.options["mergepolys"]:
            geometry = self.solid_geometry
        else:
            geometry = self.buffered_paths + \
                        [poly['polygon'] for poly in self.regions] + \
                        self.flash_geometry

        linespec = None
        if self.options["multicolored"]:
            linespec = '-'
        else:
            linespec = 'k-'

        for poly in geometry:
            x, y = poly.exterior.xy
            self.axes.plot(x, y, linespec)
            for ints in poly.interiors:
                x, y = ints.coords.xy
                self.axes.plot(x, y, linespec)


class CirkuixExcellon(CirkuixObj, Excellon):

    def __init__(self, name):
        Excellon.__init__(self)
        CirkuixObj.__init__(self, name)

        self.options = {
            "plot": True,
            "solid": False,
            "multicolored": False
        }

    def build_ui(self):
        print "build_excellon_ui()"
        osw = self.app.builder.get_object("offscrwindow_excellon")
        #box1 = self.app.builder.get_object("box_excellon")
        #osw.remove(box1)
        sw = self.app.builder.get_object("sw_excellon")
        osw.remove(sw)
        vp = self.app.builder.get_object("vp_excellon")
        vp.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(1, 1, 1, 1))
        self.app.notebook.append_page(sw, Gtk.Label("Selection"))
        entry_name = self.app.builder.get_object("entry_excellonname")
        entry_name.set_text(self.name)
        entry_name.connect("activate", self.app.on_activate_name)
        self.to_form()
        sw.show()

    def plot(self, figure):
        self.setup_axes(figure)
        self.create_geometry()

        # Plot excellon
        for geo in self.solid_geometry:
            x, y = geo.exterior.coords.xy
            self.axes.plot(x, y, 'r-')
            for ints in geo.interiors:
                x, y = ints.coords.xy
                self.axes.plot(x, y, 'g-')


class CirkuixCNCjob(CirkuixObj, CNCjob):
    def __init__(self, name, units="in", kind="generic", z_move=0.1,
                 feedrate=3.0, z_cut=-0.002, tooldia=0.0):
        CNCjob.__init__(self, units=units, kind=kind, z_move=z_move,
                        feedrate=feedrate, z_cut=z_cut, tooldia=tooldia)
        CirkuixObj.__init__(self, name)

        self.options = {
            "plot": True,
            "solid": False,
            "tooldia": 0.4/25.4  # 0.4mm in inches
        }

    def build_ui(self):
        print "build_cncjob_ui()"
        osw = self.app.builder.get_object("offscrwindow_cncjob")
        #box1 = self.app.builder.get_object("box_cncjob")
        #osw.remove(box1)
        sw = self.app.builder.get_object("sw_cncjob")
        osw.remove(sw)
        vp = self.app.builder.get_object("vp_cncjob")
        vp.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(1, 1, 1, 1))
        self.app.notebook.append_page(sw, Gtk.Label("Selection"))
        entry_name = self.app.builder.get_object("entry_cncjobname")
        entry_name.set_text(self.name)
        entry_name.connect("activate", self.app.on_activate_name)
        self.to_form()
        sw.show()

    def plot(self, figure):
        self.setup_axes(figure)
        self.plot2(self.axes, tooldia=self.options["tooldia"])


class CirkuixGeometry(CirkuixObj, Geometry):
    def __init__(self, name):
        CirkuixObj.__init__(self, name)
        self.options = {"plot": True,
                        "solid": False,
                        "multicolored": False}

        self.options = {
            "plot": True,
            "solid": False,
            "multicolored": False,
            "cutz": -0.002,
            "travelz": 0.1,
            "feedrate": 5.0
        }

    def build_ui(self):
        print "build_geometry_ui()"
        osw = self.app.builder.get_object("offscrwindow_geometry")
        #box1 = self.app.builder.get_object("box_geometry")
        #osw.remove(box1)
        sw = self.app.builder.get_object("sw_geometry")
        osw.remove(sw)
        vp = self.app.builder.get_object("vp_geometry")
        vp.override_background_color(Gtk.StateType.NORMAL, Gdk.RGBA(1, 1, 1, 1))
        self.app.notebook.append_page(sw, Gtk.Label("Selection"))
        entry_name = self.app.builder.get_object("entry_geometryname")
        entry_name.set_text(self.name)
        entry_name.connect("activate", self.app.on_activate_name)
        self.to_form()
        sw.show()

    def plot(self, figure):
        self.setup_axes(figure)

        for geo in self.solid_geometry:

            if type(geo) == Polygon:
                x, y = geo.exterior.coords.xy
                self.axes.plot(x, y, 'r-')
                for ints in geo.interiors:
                    x, y = ints.coords.xy
                    self.axes.plot(x, y, 'r-')
                continue

            if type(geo) == LineString or type(geo) == LinearRing:
                x, y = geo.coords.xy
                self.axes.plot(x, y, 'r-')
                continue


class App:
    def __init__(self):
        # Needed to interact with the GUI from other threads.
        GLib.threads_init()

        ########################################
        ##                GUI                 ##
        ########################################       
        self.gladefile = "cirkuix.ui"
        self.builder = Gtk.Builder()
        self.builder.add_from_file(self.gladefile)
        self.window = self.builder.get_object("window1")
        self.window.set_title("Cirkuix")
        self.position_label = self.builder.get_object("label3")
        self.grid = self.builder.get_object("grid1")
        self.notebook = self.builder.get_object("notebook1")
        self.info_label = self.builder.get_object("label_status")
        self.progress_bar = self.builder.get_object("progressbar")
        self.progress_bar.set_show_text(True)

        ## Event handling ##
        self.builder.connect_signals(self)
        
        ## Make plot area ##
        self.figure = None
        self.axes = None
        self.canvas = None
        self.setup_plot()
        
        self.setup_component_viewer()
        self.setup_component_editor()
        
        ########################################
        ##               DATA                 ##
        ########################################
        self.setup_obj_classes()
        self.stuff = {}    # CirkuixObj's by name
        self.mouse = None  # Mouse coordinates over plot
        
        # What is selected by the user. It is
        # a key if self.stuff
        self.selected_item_name = None

        # For debugging only
        def someThreadFunc(self):
            print "Hello World!"
        t = threading.Thread(target=someThreadFunc, args=(self,))
        t.start()

        ########################################
        ##              START                 ##
        ########################################
        self.window.show_all()
        Gtk.main()
        
    def setup_plot(self):
        self.figure = Figure(dpi=50)
        self.axes = self.figure.add_axes([0.05, 0.05, 0.9, 0.9], label="base", alpha=0.0)
        self.axes.set_aspect(1)
        #t = arange(0.0,5.0,0.01)
        #s = sin(2*pi*t)
        #self.axes.plot(t,s)
        self.axes.grid()
        self.figure.patch.set_visible(False)
        
        self.canvas = FigureCanvas(self.figure)  # a Gtk.DrawingArea
        self.canvas.set_hexpand(1)
        self.canvas.set_vexpand(1)
        
        ########################################
        ##              EVENTS                ##
        ########################################
        self.canvas.mpl_connect('button_press_event', self.on_click_over_plot)
        self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move_over_plot)
        self.canvas.set_can_focus(True)  # For key press
        self.canvas.mpl_connect('key_press_event', self.on_key_over_plot)
        #self.canvas.mpl_connect('scroll_event', self.on_scroll_over_plot)
        
        self.grid.attach(self.canvas, 0, 0, 600, 400)

    def setup_obj_classes(self):
        CirkuixObj.app = self

        CirkuixGerber.form_getters = {
            "plot": self.builder.get_object("cb_gerber_plot").get_active,
            "mergepolys": self.builder.get_object("cb_gerber_mergepolys").get_active,
            "solid": self.builder.get_object("cb_gerber_solid").get_active,
            "multicolored": self.builder.get_object("cb_gerber_multicolored").get_active,
            "isotooldia": lambda: self.get_eval("entry_gerberisotooldia"),
            "cutoutmargin": lambda: self.get_eval("entry_gerber_cutout_margin"),
            "cutoutgapsize": lambda: self.get_eval("entry_gerber_cutout_gapsize"),
            "gaps": lambda: self.get_radio_value({"rb_2tb": "tb", "rb_2lr": "lr", "rb_4": "4"}),
            "noncoppermargin": lambda: self.get_eval("entry_gerber_noncopper_margin")
        }

        CirkuixGerber.form_setters = {
            "plot": self.builder.get_object("cb_gerber_plot").set_active,
            "mergepolys": self.builder.get_object("cb_gerber_mergepolys").set_active,
            "solid": self.builder.get_object("cb_gerber_solid").set_active,
            "multicolored": self.builder.get_object("cb_gerber_multicolored").set_active,
            "isotooldia": lambda x: self.builder.get_object("entry_gerberisotooldia").set_text(str(x)),
            "cutoutmargin": lambda x: self.builder.get_object("entry_gerber_cutout_margin").set_text(str(x)),
            "cutoutgapsize": lambda x: self.builder.get_object("entry_gerber_cutout_gapsize").set_text(str(x)),
            "gaps": lambda x: self.builder.get_object("cb_gerber_solid").set_active(
                                    {"tb": "rb_2tb", "lr": "rb_2lr", "4": "rb_4"}[x]),
            "noncoppermargin": lambda x: self.builder.get_object("entry_gerber_noncopper_margin").set_text(str(x))
        }

        CirkuixExcellon.form_getters = {
            "plot": self.builder.get_object("cb_excellon_plot").get_active,
            "solid": self.builder.get_object("cb_excellon_solid").get_active,
            "multicolored": self.builder.get_object("cb_excellon_multicolored").get_active
        }

        CirkuixExcellon.form_setters = {
            "plot": self.builder.get_object("cb_excellon_plot").set_active,
            "solid": self.builder.get_object("cb_excellon_solid").set_active,
            "multicolored": self.builder.get_object("cb_excellon_multicolored").set_active
        }

        CirkuixCNCjob.form_getters = {
            "plot": self.builder.get_object("cb_cncjob_plot").get_active,
            "solid": self.builder.get_object("cb_cncjob_solid").get_active,
            "multicolored": self.builder.get_object("cb_cncjob_multicolored").get_active,
            "tooldia": lambda: self.get_eval("entry_cncjob_tooldia")
        }

        CirkuixCNCjob.form_setters = {
            "plot": self.builder.get_object("cb_cncjob_plot").set_active,
            "solid": self.builder.get_object("cb_cncjob_solid").set_active,
            "tooldia": lambda x: self.builder.get_object("entry_cncjob_tooldia").set_text(str(x))
        }

        CirkuixGeometry.form_getters = {
            "plot": self.builder.get_object("cb_geometry_plot").get_active,
            "solid": self.builder.get_object("cb_geometry_solid").get_active,
            "multicolored": self.builder.get_object("cb_geometry_multicolored").get_active,
            "cutz": lambda: self.get_eval("entry_geometry_cutz"),
            "travelz": lambda: self.get_eval("entry_geometry_travelz"),
            "feedrate": lambda: self.get_eval("entry_geometry_feedrate")
        }

        CirkuixGeometry.form_setters = {
            "plot": self.builder.get_object("cb_geometry_plot").set_active,
            "solid": self.builder.get_object("cb_geometry_solid").set_active,
            "multicolored": self.builder.get_object("cb_geometry_multicolored").set_active,
            "cutz": lambda x: self.builder.get_object("entry_geometry_cutz").set_text(str(x)),
            "travelz": lambda x: self.builder.get_object("entry_geometry_travelz").set_text(str(x)),
            "feedrate": lambda x: self.builder.get_object("entry_geometry_feedrate").set_text(str(x))
        }

    def setup_component_viewer(self):
        """
        List or Tree where whatever has been loaded or created is
        displayed.
        """
        self.store = Gtk.ListStore(str)
        self.tree = Gtk.TreeView(self.store)
        #self.list = Gtk.ListBox()
        self.tree_select  = self.tree.get_selection()
        self.signal_id = self.tree_select.connect("changed", self.on_tree_selection_changed)
        renderer = Gtk.CellRendererText()
        column = Gtk.TreeViewColumn("Title", renderer, text=0)
        self.tree.append_column(column)
        self.builder.get_object("notebook1").append_page(self.tree, Gtk.Label("Project"))
        
    def setup_component_editor(self):
        box1 = Gtk.Box(Gtk.Orientation.VERTICAL)
        label1 = Gtk.Label("Choose an item from Project")
        box1.pack_start(label1, False, False, 1)
        self.builder.get_object("notebook1").append_page(box1, Gtk.Label("Selection"))

    def info(self, text):
        """
        Show text on the status bar.
        """
        self.info_label.set_text(text)

    def zoom(self, factor, center=None):
        """
        Zooms the plot by factor around a given
        center point. Takes care of re-drawing.
        """
        xmin, xmax = self.axes.get_xlim()
        ymin, ymax = self.axes.get_ylim()
        width = xmax-xmin
        height = ymax-ymin

        if center is None:
            center = [(xmin+xmax)/2.0, (ymin+ymax)/2.0]

        # For keeping the point at the pointer location
        relx = (xmax-center[0])/width
        rely = (ymax-center[1])/height

        new_width = width/factor
        new_height = height/factor

        xmin = center[0]-new_width*(1-relx)
        xmax = center[0]+new_width*relx
        ymin = center[1]-new_height*(1-rely)
        ymax = center[1]+new_height*rely

        for name in self.stuff:
            self.stuff[name].axes.set_xlim((xmin, xmax))
            self.stuff[name].axes.set_ylim((ymin, ymax))
        self.axes.set_xlim((xmin, xmax))
        self.axes.set_ylim((ymin, ymax))

        self.canvas.queue_draw()

    def build_list(self):
        self.store.clear()
        for key in self.stuff:
            self.store.append([key])

    def get_radio_value(self, radio_set):
        """
        Returns the radio_set[key] if the radiobutton
        whose name is key is active.
        """
        for name in radio_set:
            if self.builder.get_object(name).get_active():
                return radio_set[name]

    def plot_all(self):
        self.clear_plots()
        
        for i in self.stuff:
            self.stuff[i].plot(self.figure)
        
        self.on_zoom_fit(None)
        self.axes.grid()
        self.canvas.queue_draw()
        
    def clear_plots(self):
        self.axes.cla()
        self.figure.clf()
        self.figure.add_axes(self.axes)
        self.canvas.queue_draw()

    def get_eval(self, widget_name):
        value = self.builder.get_object(widget_name).get_text()
        return eval(value)

    def set_list_selection(self, name):
        iter = self.store.get_iter_first()
        while iter is not None and self.store[iter][0] != name:
            iter = self.store.iter_next(iter)
        self.tree_select.unselect_all()
        self.tree_select.select_iter(iter)

    ########################################
    ##         EVENT HANDLERS             ##
    ########################################
    def on_gerber_generate_noncopper(self, widget):
        gerber = self.stuff[self.selected_item_name]
        gerber.read_form()

        name = self.selected_item_name + "_noncopper"

        bounding_box = gerber.solid_geometry.envelope.buffer(gerber.options["noncoppermargin"])

        non_copper = bounding_box.difference(gerber.solid_geometry)

        geometry = CirkuixGeometry(name)
        geometry.solid_geometry = non_copper

        self.stuff[name] = geometry
        self.build_list()


    def on_gerber_generate_cutout(self, widget):
        margin = self.get_eval("entry_gerber_cutout_margin")
        gap_size = self.get_eval("entry_gerber_cutout_gapsize")
        gerber = self.stuff[self.selected_item_name]
        minx, miny, maxx, maxy = gerber.bounds()
        minx -= margin
        maxx += margin
        miny -= margin
        maxy += margin
        midx = 0.5 * (minx + maxx)
        midy = 0.5 * (miny + maxy)
        hgap = 0.5 * gap_size
        pts = [[midx-hgap, maxy],
               [minx, maxy],
               [minx, midy+hgap],
               [minx, midy-hgap],
               [minx, miny],
               [midx-hgap, miny],
               [midx+hgap, miny],
               [maxx, miny],
               [maxx, midy-hgap],
               [maxx, midy+hgap],
               [maxx, maxy],
               [midx+hgap, maxy]]
        cases = {"tb": [[pts[0], pts[1], pts[4], pts[5]],
                        [pts[6], pts[7], pts[10], pts[11]]],
                 "lr": [[pts[9], pts[10], pts[1], pts[2]],
                        [pts[3], pts[4], pts[7], pts[8]]],
                 "4": [[pts[0], pts[1], pts[2]],
                       [pts[3], pts[4], pts[5]],
                       [pts[6], pts[7], pts[8]],
                       [pts[9], pts[10], pts[11]]]}
        name = self.selected_item_name + "_cutout"
        geometry = CirkuixGeometry(name)
        cuts = None
        if self.builder.get_object("rb_2tb").get_active():
            cuts = cases["tb"]
        elif self.builder.get_object("rb_2lr").get_active():
            cuts = cases["lr"]
        else:
            cuts = cases["4"]
        geometry.solid_geometry = cascaded_union([LineString(segment) for segment in cuts])

        # Add to App and update.
        self.stuff[name] = geometry
        self.build_list()

    def on_eval_update(self, widget):
        """
        Modifies the content of a Gtk.Entry by running
        eval() on its contents and puting it back as a
        string.
        """
        # TODO: error handling here
        widget.set_text(str(eval(widget.get_text())))

    def on_generate_isolation(self, widget):
        print "Generating Isolation Geometry:"
        # Get required info
        tooldia = self.builder.get_object("entry_gerberisotooldia").get_text()
        tooldia = eval(tooldia)
        print "tooldia:", tooldia
        
        # Generate
        iso = self.stuff[self.selected_item_name].isolation_geometry(tooldia/2.0)
        # TODO: This will break if there is something with this name already        
        iso_name = self.selected_item_name + "_iso"
        geo = CirkuixGeometry(iso_name)
        geo.solid_geometry = iso

        # Add to App and update.        
        self.stuff[iso_name] = geo        
        self.build_list()
        
    def on_generate_cncjob(self, widget):
        print "Generating CNC job"
        # Get required info
        cutz = self.get_eval("entry_geometry_cutz")
        travelz = self.get_eval("entry_geometry_travelz")
        feedrate = self.get_eval("entry_geometry_feedrate")
        
        geometry = self.stuff[self.selected_item_name]
        job_name = self.selected_item_name + "_cnc"
        job = CirkuixCNCjob(job_name, z_move=travelz, z_cut=cutz, feedrate=feedrate)
        job.generate_from_geometry(geometry.solid_geometry)
        job.gcode_parse()
        job.create_geometry()
        
        # Add to App and update.        
        self.stuff[job_name] = job      
        self.build_list()

    def on_cncjob_tooldia_activate(self, widget):
        job = self.stuff[self.selected_item_name]
        tooldia = self.get_eval("entry_cncjob_tooldia")
        job.tooldia = tooldia
        print "Changing tool diameter to:", tooldia

    def on_cncjob_exportgcode(self, widget):
        def on_success(self, filename):
            cncjob = self.stuff[self.selected_item_name]
            f = open(filename, 'w')
            f.write(cncjob.gcode)
            f.close()
            print "Saved to:", filename
        self.file_chooser_save_action(on_success)

    def on_delete(self, widget):
        self.stuff.pop(self.selected_item_name)
        
        #self.tree.get_selection().disconnect(self.signal_id)
        self.build_list() # Update the items list
        #self.signal_id = self.tree.get_selection().connect(
        #                     "changed", self.on_tree_selection_changed)
                             
        self.plot_all()
        #self.notebook.set_current_page(1)
                             
    def on_replot(self, widget):
        self.plot_all()
    
    def on_clear_plots(self, widget):
        self.clear_plots()
        
    def on_activate_name(self, entry):
        '''
        Hitting 'Enter' after changing the name of an item
        updates the item dictionary and re-builds the item list.
        '''
        print "Changing name"
        self.tree.get_selection().disconnect(self.signal_id)
        new_name = entry.get_text()  # Get from form
        self.stuff[new_name] = self.stuff.pop(self.selected_item_name)  # Update dictionary
        self.selected_item_name = new_name  # Update selection name
        self.build_list()  # Update the items list
        self.signal_id = self.tree.get_selection().connect(
                             "changed", self.on_tree_selection_changed)
                             
    def on_tree_selection_changed(self, selection):
        model, treeiter = selection.get_selected()

        if treeiter is not None:
            print "You selected", model[treeiter][0]
        else:
            return  # TODO: Clear "Selected" page
        
        self.selected_item_name = model[treeiter][0]
        # Remove the current selection page
        # from the notebook
        # TODO: Assuming it was last page or #2. Find the right page
        self.builder.get_object("notebook1").remove_page(2)

        self.stuff[self.selected_item_name].build_ui()

        # Determine the kind of item selected
        #kind = self.stuff[model[treeiter][0]].kind
        
        # Build the UI
        # builder = {"gerber": self.build_gerber_ui,
        #            "excellon": self.build_excellon_ui,
        #            "cncjob": self.build_cncjob_ui,
        #            "geometry": self.build_geometry_ui}
        # builder[kind]()
    
    def on_filequit(self, param):
        print "quit from menu"
        self.window.destroy()
        Gtk.main_quit()
    
    def on_closewindow(self, param):
        print "quit from X"
        self.window.destroy()
        Gtk.main_quit()
    
    def file_chooser_action(self, on_success):
        '''
        Opens the file chooser and runs on_success on a separate thread
        upon completion of valid file choice.
        '''
        dialog = Gtk.FileChooserDialog("Please choose a file", self.window,
            Gtk.FileChooserAction.OPEN,
            (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
             Gtk.STOCK_OPEN, Gtk.ResponseType.OK))
        response = dialog.run()
        if response == Gtk.ResponseType.OK:
            filename = dialog.get_filename()
            dialog.destroy()
            t = threading.Thread(target=on_success, args=(self, filename))
            t.daemon = True
            t.start()
            #on_success(self, filename)
        elif response == Gtk.ResponseType.CANCEL:
            print("Cancel clicked")
            dialog.destroy()    
    
    def file_chooser_save_action(self, on_success):
        """
        Opens the file chooser and runs on_success
        upon completion of valid file choice.
        """
        dialog = Gtk.FileChooserDialog("Save file", self.window,
            Gtk.FileChooserAction.SAVE,
            (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
             Gtk.STOCK_SAVE, Gtk.ResponseType.OK))
        dialog.set_current_name("Untitled")
        response = dialog.run()
        if response == Gtk.ResponseType.OK:
            filename = dialog.get_filename()
            dialog.destroy()
            on_success(self, filename)
        elif response == Gtk.ResponseType.CANCEL:
            print("Cancel clicked")
            dialog.destroy()
    
    def on_fileopengerber(self, param):
        def on_success(self, filename):
            self.progress_bar.set_text("Opening Gerber ...")
            self.progress_bar.set_fraction(0.1)

            name = filename.split('/')[-1].split('\\')[-1]
            gerber = CirkuixGerber(name)

            self.progress_bar.set_text("Parsing ...")
            self.progress_bar.set_fraction(0.2)

            gerber.parse_file(filename)
            self.store.append([name])
            self.stuff[name] = gerber

            self.progress_bar.set_text("Plotting ...")
            self.progress_bar.set_fraction(0.6)

            #self.plot_gerber(gerber)
            gerber.plot(self.figure)
            gerber.axes.set_alpha(0.0)
            self.on_zoom_fit(None)

            self.progress_bar.set_text("Done!")
            self.progress_bar.set_fraction(1.0)

            self.notebook.set_current_page(1)
            self.set_list_selection(name)

            def clear_bar(bar):
                bar.set_text("")
                bar.set_fraction(0.0)

            threading.Timer(1, clear_bar, args=(self.progress_bar,)).start()
        self.file_chooser_action(on_success)
    
    def on_fileopenexcellon(self, param):
        def on_success(self, filename):
            self.progress_bar.set_text("Opening Excellon ...")
            self.progress_bar.set_fraction(0.1)

            name = filename.split('/')[-1].split('\\')[-1]
            excellon = CirkuixExcellon(name)

            self.progress_bar.set_text("Parsing ...")
            self.progress_bar.set_fraction(0.2)

            excellon.parse_file(filename)
            self.store.append([name])
            self.stuff[name] = excellon

            self.progress_bar.set_text("Plotting ...")
            self.progress_bar.set_fraction(0.6)

            #self.plot_excellon(excellon)
            excellon.plot(self.figure)
            self.on_zoom_fit(None)

            self.progress_bar.set_text("Done!")
            self.progress_bar.set_fraction(1.0)

            def clear_bar(bar):
                bar.set_text("")
                bar.set_fraction(0.0)
            threading.Timer(1, clear_bar, args=(self.progress_bar,)).start()

        self.file_chooser_action(on_success)
    
    def on_fileopengcode(self, param):
        def on_success(self, filename):
            self.progress_bar.set_text("Opening G-Code ...")
            self.progress_bar.set_fraction(0.1)

            name = filename.split('/')[-1].split('\\')[-1]
            f = open(filename)
            gcode = f.read()
            f.close()
            tooldia = self.get_eval("entry_tooldia")
            job = CirkuixCNCjob(name, tooldia=tooldia)
            job.gcode = gcode

            self.progress_bar.set_text("Parsing ...")
            self.progress_bar.set_fraction(0.2)

            job.gcode_parse()
            job.create_geometry()
            self.store.append([name])
            self.stuff[name] = job

            self.progress_bar.set_text("Plotting ...")
            self.progress_bar.set_fraction(0.6)

            #self.plot_cncjob(job)
            job.plot(self.figure)
            self.on_zoom_fit(None)

            self.progress_bar.set_text("Done!")
            self.progress_bar.set_fraction(1.0)

            def clear_bar(bar):
                bar.set_text("")
                bar.set_fraction(0.0)
            threading.Timer(1, clear_bar, args=(self.progress_bar,)).start()
        self.file_chooser_action(on_success)
        
    def on_mouse_move_over_plot(self, event):
        try: # May fail in case mouse not within axes
            self.position_label.set_label("X: %.4f   Y: %.4f"%(
                                         event.xdata, event.ydata))
            self.mouse = [event.xdata, event.ydata]
        except:
            self.position_label.set_label("")
            self.mouse = None
        
    def on_click_over_plot(self, event):
        # For key presses
        self.canvas.grab_focus()
        
        print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(
        event.button, event.x, event.y, event.xdata, event.ydata)
        
    def on_zoom_in(self, event):
        self.zoom(1.5)
        return
        
    def on_zoom_out(self, event):
        self.zoom(1/1.5)
         
    def on_zoom_fit(self, event):
        xmin, ymin, xmax, ymax = get_bounds(self.stuff)
        width = xmax-xmin
        height = ymax-ymin
        r = width/height
        
        Fw, Fh = self.canvas.get_width_height()
        Fr = float(Fw)/Fh
        print "Window aspect ratio:", Fr
        print "Data aspect ratio:", r
        
        #self.axes.set_xlim((xmin-0.05*width, xmax+0.05*width))
        #self.axes.set_ylim((ymin-0.05*height, ymax+0.05*height))
        
        if r > Fr:
            #self.axes.set_xlim((xmin-0.05*width, xmax+0.05*width))
            xmin -= 0.05*width
            xmax += 0.05*width
            ycenter = (ymin+ymax)/2.0
            newheight = height*r/Fr
            ymin = ycenter-newheight/2.0
            ymax = ycenter+newheight/2.0
            #self.axes.set_ylim((ycenter-newheight/2.0, ycenter+newheight/2.0))
        else:
            #self.axes.set_ylim((ymin-0.05*height, ymax+0.05*height))
            ymin -= 0.05*height
            ymax += 0.05*height
            xcenter = (xmax+ymin)/2.0
            newwidth = width*Fr/r
            xmin = xcenter-newwidth/2.0
            xmax = xcenter+newwidth/2.0
            #self.axes.set_xlim((xcenter-newwidth/2.0, xcenter+newwidth/2.0))

        for name in self.stuff:
            self.stuff[name].axes.set_xlim((xmin, xmax))
            self.stuff[name].axes.set_ylim((ymin, ymax))
        self.axes.set_xlim((xmin, xmax))
        self.axes.set_ylim((ymin, ymax))

        self.canvas.queue_draw()
        return
        
    # def on_scroll_over_plot(self, event):
    #     print "Scroll"
    #     center = [event.xdata, event.ydata]
    #     if sign(event.step):
    #         self.zoom(1.5, center=center)
    #     else:
    #         self.zoom(1/1.5, center=center)
    #
    # def on_window_scroll(self, event):
    #     print "Scroll"
        
    def on_key_over_plot(self, event):
        print 'you pressed', event.key, event.xdata, event.ydata
        
        if event.key == '1': # 1
            self.on_zoom_fit(None)
            return
            
        if event.key == '2': # 2
            self.zoom(1/1.5, self.mouse)
            return
            
        if event.key == '3': # 3
            self.zoom(1.5, self.mouse)
            return

app = App()