diff --git a/frc971/control_loops/python/graph.py b/frc971/control_loops/python/graph.py
index 3063bd1..1b83713 100644
--- a/frc971/control_loops/python/graph.py
+++ b/frc971/control_loops/python/graph.py
@@ -1,209 +1,55 @@
-from constants import *
-import cairo
-from color import Color, palette
+import gi
+gi.require_version('Gtk', '3.0')
+from gi.repository import Gtk
+import numpy as np
 from points import Points
-from drawing_constants import *
 from libspline import Spline, DistanceSpline, Trajectory
 
-AXIS_MARGIN_SPACE = 40
+from matplotlib.backends.backend_gtk3agg import (FigureCanvasGTK3Agg as
+                                                 FigureCanvas)
+from matplotlib.figure import Figure
 
 
-class Graph():  # (TODO): Remove Computer Calculation
-    def __init__(self, cr, mypoints):
-        # Background Box
-        set_color(cr, palette["WHITE"])
-        cr.rectangle(-1.0 * SCREEN_SIZE, -0.5 * SCREEN_SIZE, SCREEN_SIZE,
-                     SCREEN_SIZE * 0.6)
-        cr.fill()
+class Graph(Gtk.Bin):
+    def __init__(self):
+        super(Graph, self).__init__()
+        fig = Figure(figsize=(5, 4), dpi=100)
+        self.axis = fig.add_subplot(111)
+        canvas = FigureCanvas(fig)  # a Gtk.DrawingArea
+        canvas.set_vexpand(True)
+        canvas.set_size_request(800, 250)
+        self.add(canvas)
 
-        cr.set_source_rgb(0, 0, 0)
-        cr.rectangle(-1.0 * SCREEN_SIZE, -0.5 * SCREEN_SIZE, SCREEN_SIZE,
-                     SCREEN_SIZE * 0.6)
-        #Axis
-        cr.move_to(-1.0 * SCREEN_SIZE + AXIS_MARGIN_SPACE,
-                   -0.5 * SCREEN_SIZE + AXIS_MARGIN_SPACE)  # Y
-        cr.line_to(-1.0 * SCREEN_SIZE + AXIS_MARGIN_SPACE,
-                   0.1 * SCREEN_SIZE - 10)
+    def recalculate_graph(self, points):
+        if not points.getLibsplines(): return
 
-        cr.move_to(-1.0 * SCREEN_SIZE + AXIS_MARGIN_SPACE,
-                   -0.5 * SCREEN_SIZE + AXIS_MARGIN_SPACE)  # X
-        cr.line_to(-10, -0.5 * SCREEN_SIZE + AXIS_MARGIN_SPACE)
-        cr.stroke()
+        # set the size of a timestep
+        dt = 0.00505
 
-        skip = 2
-        dT = 0.00505
-        start = AXIS_MARGIN_SPACE - SCREEN_SIZE
-        end = -2.0 * AXIS_MARGIN_SPACE
-        height = 0.5 * (SCREEN_SIZE) - AXIS_MARGIN_SPACE
-        zero = AXIS_MARGIN_SPACE - SCREEN_SIZE / 2.0
-        legend_entries = {}
-        if mypoints.getLibsplines():
-            distanceSpline = DistanceSpline(mypoints.getLibsplines())
-            traj = Trajectory(distanceSpline)
-            mypoints.addConstraintsToTrajectory(traj)
-            traj.Plan()
-            XVA = traj.GetPlanXVA(dT)
-            if XVA is not None:
-                self.draw_x_axis(cr, start, height, zero, XVA, end)
-                self.drawVelocity(cr, XVA, start, height, skip, zero, end,
-                                  legend_entries)
-                self.drawAcceleration(cr, XVA, start, height, skip, zero,
-                                      AXIS_MARGIN_SPACE, end, legend_entries)
-                self.drawVoltage(cr, XVA, start, height, skip, traj, zero, end,
-                                 legend_entries)
-                cr.set_source_rgb(0, 0, 0)
-                cr.move_to(-1.0 * AXIS_MARGIN_SPACE, zero + height / 2.0)
-                cr.line_to(AXIS_MARGIN_SPACE - SCREEN_SIZE,
-                           zero + height / 2.0)
-                self.drawLegend(cr, XVA, start, height, skip, zero, end,
-                                legend_entries)
-        cr.stroke()
+        # call C++ wrappers to calculate the trajectory
+        distanceSpline = DistanceSpline(points.getLibsplines())
+        traj = Trajectory(distanceSpline)
+        points.addConstraintsToTrajectory(traj)
+        traj.Plan()
+        XVA = traj.GetPlanXVA(dt)
 
-    def connectLines(self, cr, points, color):
-        for i in range(0, len(points) - 1):
-            set_color(cr, color)
-            cr.move_to(points[i][0], points[i][1])
-            cr.line_to(points[i + 1][0], points[i + 1][1])
-            cr.stroke()
+        # extract values to be graphed
+        total_steps_taken = XVA.shape[1]
+        total_time = dt * total_steps_taken
+        time = np.arange(total_time, step=dt)
+        position, velocity, acceleration = XVA
+        left_voltage, right_voltage = zip(*(traj.Voltage(x) for x in position))
 
-    def draw_x_axis(self, cr, start, height, zero, xva, end):
-        total_time = 0.00505 * len(xva[0])
-        for k in np.linspace(0, 1, 11):
-            self.tickMark(cr,
-                          k * np.abs(start - end) + start, zero + height / 2.0,
-                          10, palette["BLACK"])
-            cr.move_to(k * np.abs(start - end) + start,
-                       10 + zero + height / 2.0)
-            txt_scale = SCREEN_SIZE / 1000.0
-            display_text(cr, str(round(k * total_time, 3)), txt_scale,
-                         txt_scale, 1.0 / txt_scale, 1.0 / txt_scale)
-            cr.stroke()
+        # update graph
+        self.axis.clear()
+        self.axis.plot(time, velocity)
+        self.axis.plot(time, acceleration)
+        self.axis.plot(time, left_voltage)
+        self.axis.plot(time, right_voltage)
+        self.axis.legend(
+            ["Velocity", "Acceleration", "Left Voltage", "Right Voltage"])
+        self.axis.xaxis.set_label_text("Time (sec)")
 
-    def tickMark(self, cr, x, y, height, COLOR):
-        # X, Y is in the middle of the tick mark
-        set_color(cr, COLOR)
-        cr.move_to(x, y + (height / 2))
-        cr.line_to(x, y - (height / 2))
-        cr.stroke()
-
-    def HtickMark(self, cr, x, y, width, COLOR):
-        # X, Y is in the middle of the tick mark
-        set_color(cr, COLOR)
-        cr.move_to(x + (width / 2), y)
-        cr.line_to(x - (width / 2), y)
-        cr.stroke()
-
-    def drawLegend(self, cr, xva, start, height, skip, zero, end,
-                   legend_entries):
-        step_size = (end - start) / len(legend_entries)
-        margin_under_x_axis = height * 0.1
-        for index, (name, color) in enumerate(legend_entries.items()):
-            set_color(cr, color)
-            cr.move_to(start + index * step_size, zero - margin_under_x_axis)
-            txt_scale = SCREEN_SIZE / 900.0
-            display_text(cr, name, txt_scale, txt_scale, 1.0 / txt_scale,
-                         1.0 / txt_scale)
-
-    def drawVelocity(self, cr, xva, start, height, skip, zero, end,
-                     legend_entries):
-        COLOR = palette["RED"]
-        velocity = xva[1]
-        n_timesteps = len(velocity)
-        max_v = np.amax(velocity)
-        spacing = np.abs(start - end) / float(n_timesteps)
-        scaler = height / max_v
-        cr.set_source_rgb(1, 0, 0)
-        points = []
-        for i in range(0, len(velocity)):
-            if i % skip == 0:
-                points.append([
-                    start + (i * spacing),
-                    zero + height / 2.0 + (velocity[i] * scaler / 2.0)
-                ])
-        self.connectLines(cr, points, COLOR)
-
-        # draw axes marking
-        for i in np.linspace(-1, 1, 11):
-            self.HtickMark(cr, start, zero + i * height / 2.0 + height / 2.0,
-                           10, palette["BLACK"])
-            cr.set_source_rgb(1, 0, 0)
-            cr.move_to(start + 5, zero + i * height / 2.0 + height / 2.0)
-            txt_scale = SCREEN_SIZE / 1000.0
-            display_text(cr, str(round(i * max_v, 2)), txt_scale, txt_scale,
-                         1.0 / txt_scale, 1.0 / txt_scale)
-            cr.stroke()
-
-        # add entry to legend
-        legend_entries["Velocity"] = COLOR
-
-    def drawAcceleration(self, cr, xva, start, height, skip, zero, margin, end,
-                         legend_entries):
-        COLOR = palette["BLUE"]
-        accel = xva[2]
-        max_a = np.amax(accel)
-        min_a = np.amin(accel)
-        n_timesteps = len(accel)
-        spacing = np.abs(start - end) / float(n_timesteps)
-        scaler = height / (max_a - min_a)
-        cr.set_source_rgb(1, 0, 0)
-        points = []
-        for i in range(0, len(accel)):
-            if i % skip == 0:
-                points.append([
-                    start + (i * spacing), zero + ((accel[i] - min_a) * scaler)
-                ])
-        self.connectLines(cr, points, COLOR)
-
-        # draw axes marking
-        for i in np.linspace(0, 1, 11):
-            self.HtickMark(cr, -1.5 * margin, zero + i * height, 10,
-                           palette["BLACK"])
-            cr.set_source_rgb(0, 0, 1)
-            cr.move_to(-1.2 * margin, zero + i * height)
-            txt_scale = SCREEN_SIZE / 1000.0
-            display_text(cr, str(round(i * (max_a - min_a) + min_a,
-                                       2)), txt_scale, txt_scale,
-                         1.0 / txt_scale, 1.0 / txt_scale)
-            cr.stroke()
-
-        # draw legend
-        legend_entries["Acceleration"] = COLOR
-
-    def drawVoltage(self, cr, xva, start, height, skip, traj, zero, end,
-                    legend_entries):
-        COLOR_LEFT = palette["GREEN"]
-        COLOR_RIGHT = palette["CYAN"]
-        poses = xva[0]
-        n_timesteps = len(poses)
-        spacing = np.abs(start - end) / float(n_timesteps)
-        points_left = []
-        points_right = []
-        for i in range(0, len(poses)):
-            if i % skip == 0:
-                # libspline says the order is left-right
-                voltage = traj.Voltage(poses[i])
-                points_left.append([
-                    start + (i * spacing),
-                    zero + height / 2 + height * (voltage[0] / 24.0)
-                ])
-                points_right.append([
-                    start + (i * spacing),
-                    zero + height / 2 + height * (voltage[1] / 24.0)
-                ])
-        self.connectLines(cr, points_left, COLOR_LEFT)
-        self.connectLines(cr, points_right, COLOR_RIGHT)
-
-        for i in np.linspace(-1, 1, 7):
-            self.HtickMark(cr, -1.0 * SCREEN_SIZE,
-                           zero + i * height / 2.0 + height / 2.0, 10,
-                           palette["BLACK"])
-            cr.set_source_rgb(0, 1, 1)
-            cr.move_to(-1.0 * SCREEN_SIZE,
-                       zero + i * height / 2.0 + height / 2.0)
-            txt_scale = SCREEN_SIZE / 1000.0
-            display_text(cr, str(round(i * 12.0, 2)), txt_scale, txt_scale,
-                         1.0 / txt_scale, 1.0 / txt_scale)
-            cr.stroke()
-
-        legend_entries["Left Voltage"] = COLOR_LEFT
-        legend_entries["Right Voltage"] = COLOR_RIGHT
+        # renumber the x-axis to include the last point,
+        # the total time to drive the spline
+        self.axis.xaxis.set_ticks(np.linspace(0, total_time, num=8))
diff --git a/frc971/control_loops/python/path_edit.py b/frc971/control_loops/python/path_edit.py
index 6ddcb1c..d402593 100755
--- a/frc971/control_loops/python/path_edit.py
+++ b/frc971/control_loops/python/path_edit.py
@@ -2,58 +2,51 @@
 from __future__ import print_function
 import os
 import sys
-import copy
-from color import Color, palette
-import random
+from color import palette
+from graph import Graph
 import gi
 import numpy as np
-import scipy.spatial.distance
 gi.require_version('Gtk', '3.0')
 gi.require_version('Gdk', '3.0')
 from gi.repository import Gdk, Gtk, GLib
 import cairo
-from libspline import Spline, DistanceSpline, Trajectory
+from libspline import Spline
 import enum
 import json
-from basic_window import *
 from constants import *
-from drawing_constants import *
+from drawing_constants import set_color, draw_px_cross, draw_px_x, display_text, draw_control_points
 from points import Points
-from graph import Graph
+import time
 
 
 class Mode(enum.Enum):
     kViewing = 0
     kPlacing = 1
     kEditing = 2
-    kExporting = 3
-    kImporting = 4
 
 
-class GTK_Widget(BaseWindow):
+class FieldWidget(Gtk.DrawingArea):
     """Create a GTK+ widget on which we will draw using Cairo"""
 
     def __init__(self):
-        super(GTK_Widget, self).__init__()
+        super(FieldWidget, self).__init__()
+        self.set_size_request(mToPx(FIELD.width), mToPx(FIELD.length))
 
         self.points = Points()
+        self.graph = Graph()
+        self.set_vexpand(True)
+        self.set_hexpand(True)
 
         # init field drawing
         # add default spline for testing purposes
         # init editing / viewing modes and pointer location
         self.mode = Mode.kPlacing
-        self.x = 0
-        self.y = 0
-        module_path = os.path.dirname(os.path.realpath(sys.argv[0]))
-        self.path_to_export = os.path.join(module_path,
+        self.mousex = 0
+        self.mousey = 0
+        self.module_path = os.path.dirname(os.path.realpath(sys.argv[0]))
+        self.path_to_export = os.path.join(self.module_path,
                                            'points_for_pathedit.json')
 
-        # update list of control points
-        self.point_selected = False
-        # self.adding_spline = False
-        self.index_of_selected = -1
-        self.new_point = []
-
         # For the editing mode
         self.index_of_edit = -1  # Can't be zero beause array starts at 0
         self.held_x = 0
@@ -62,59 +55,12 @@
         self.curves = []
 
         try:
-            self.field_png = cairo.ImageSurface.create_from_png("frc971/control_loops/python/field_images/" + FIELD.field_id + ".png")
+            self.field_png = cairo.ImageSurface.create_from_png(
+                "frc971/control_loops/python/field_images/" + FIELD.field_id +
+                ".png")
         except cairo.Error:
             self.field_png = None
 
-        self.colors = []
-
-        for c in palette:
-            self.colors.append(palette[c])
-
-        self.reinit_extents()
-
-        self.inStart = None
-        self.inEnd = None
-        self.inValue = None
-        self.startSet = False
-
-        self.module_path = os.path.dirname(os.path.realpath(sys.argv[0]))
-
-    """set extents on images"""
-
-    def reinit_extents(self):
-        self.extents_x_min = -1.0 * SCREEN_SIZE
-        self.extents_x_max = SCREEN_SIZE
-        self.extents_y_min = -1.0 * SCREEN_SIZE
-        self.extents_y_max = SCREEN_SIZE
-
-    # this needs to be rewritten with numpy, i dont think this ought to have
-    # SciPy as a dependecy
-    def get_index_of_nearest_point(self):
-        cur_p = [[self.x, self.y]]
-        distances = scipy.spatial.distance.cdist(cur_p, self.all_controls)
-
-        return np.argmin(distances)
-
-    # return the closest point to the loc of the click event
-    def get_nearest_point(self):
-        return self.all_controls[self.get_index_of_nearest_point()]
-
-    def draw_field_elements(self, cr):
-        if FIELD.year == 2019:
-            draw_HAB(cr)
-            draw_rockets(cr)
-            draw_cargo_ship(cr)
-        elif FIELD.year == 2020:
-            set_color(cr, palette["BLACK"])
-            markers(cr)
-            draw_shield_generator(cr)
-            draw_trench_run(cr)
-            draw_init_lines(cr)
-            draw_control_panel(cr)
-        elif FIELD.year == 2021:
-            draw_at_home_grid(cr)
-
     def draw_robot_at_point(self, cr, i, p, spline):
         p1 = [mToPx(spline.Point(i)[0]), mToPx(spline.Point(i)[1])]
         p2 = [mToPx(spline.Point(i + p)[0]), mToPx(spline.Point(i + p)[1])]
@@ -123,8 +69,10 @@
         distance = np.sqrt((p2[1] - p1[1])**2 + (p2[0] - p1[0])**2)
         x_difference_o = p2[0] - p1[0]
         y_difference_o = p2[1] - p1[1]
-        x_difference = x_difference_o * mToPx(FIELD.robot.length / 2) / distance
-        y_difference = y_difference_o * mToPx(FIELD.robot.length / 2) / distance
+        x_difference = x_difference_o * mToPx(
+            FIELD.robot.length / 2) / distance
+        y_difference = y_difference_o * mToPx(
+            FIELD.robot.length / 2) / distance
 
         front_middle = []
         front_middle.append(p1[0] + x_difference)
@@ -212,41 +160,23 @@
         cr.stroke()
         cr.set_source_rgba(0, 0, 0, 1)
 
-    def handle_draw(self, cr):  # main
-        # Fill the background color of the window with grey
-        set_color(cr, palette["WHITE"])
-        cr.paint()
+    def do_draw(self, cr):  # main
 
-        # Draw a extents rectangle
-        set_color(cr, palette["WHITE"])
-        cr.rectangle(self.extents_x_min, self.extents_y_min,
-                     (self.extents_x_max - self.extents_x_min),
-                     self.extents_y_max - self.extents_y_min)
-        cr.fill()
-
-        cr.move_to(0, 50)
-        cr.show_text('Press "e" to export')
-        cr.show_text('Press "i" to import')
+        start_time = time.perf_counter()
 
         cr.save()
         set_color(cr, palette["BLACK"])
 
-        if FIELD.year == 2019:  # half field
-            cr.rectangle(0, -SCREEN_SIZE / 2, SCREEN_SIZE, SCREEN_SIZE)
-        else:  # full field
-            cr.translate(mToPx(FIELD.width) / 2.0, 0.0)
-            cr.rectangle(-mToPx(FIELD.width) / 2.0, -mToPx(FIELD.length) / 2.0,
-                         mToPx(FIELD.width), mToPx(FIELD.length))
+        cr.rectangle(0, 0, mToPx(FIELD.width), mToPx(FIELD.length))
         cr.set_line_join(cairo.LINE_JOIN_ROUND)
         cr.stroke()
 
         if self.field_png:
             cr.save()
-            cr.translate(-mToPx(FIELD.width) / 2, -mToPx(FIELD.length) / 2)
             cr.scale(
-                    mToPx(FIELD.width) / self.field_png.get_width(),
-                    mToPx(FIELD.length) / self.field_png.get_height(),
-                    )
+                mToPx(FIELD.width) / self.field_png.get_width(),
+                mToPx(FIELD.length) / self.field_png.get_height(),
+            )
             cr.set_source_surface(self.field_png)
             cr.paint()
             cr.restore()
@@ -255,7 +185,6 @@
 
         if self.mode == Mode.kPlacing or self.mode == Mode.kViewing:
             set_color(cr, palette["BLACK"])
-            cr.move_to(-SCREEN_SIZE, 170)
             plotPoints = self.points.getPoints()
             if plotPoints:
                 for i, point in enumerate(plotPoints):
@@ -302,9 +231,12 @@
 
         cr.paint_with_alpha(0.2)
 
-        draw_px_cross(cr, self.x, self.y, 10)
+        draw_px_cross(cr, self.mousex, self.mousey, 10)
         cr.restore()
-        mygraph = Graph(cr, self.points)
+        if self.points.getLibsplines():
+            self.graph.recalculate_graph(self.points)
+
+        print("spent {:.2f} ms drawing the field widget".format(1000 * (time.perf_counter() - start_time)))
 
     def draw_splines(self, cr):
         holder_spline = []
@@ -332,17 +264,18 @@
         self.curves.append(holder_spline)
 
     def mouse_move(self, event):
-        old_x = self.x
-        old_y = self.y
-        self.x = event.x - mToPx(FIELD.width / 2.0)
-        self.y = event.y
-        dif_x = self.x - old_x
-        dif_y = self.y - old_y
+        old_x = self.mousex
+        old_y = self.mousey
+        self.mousex = event.x
+        self.mousey = event.y
+        dif_x = self.mousex - old_x
+        dif_y = self.mousey - old_y
         difs = np.array([pxToM(dif_x), pxToM(dif_y)])
 
         if self.mode == Mode.kEditing:
-            self.points.updates_for_mouse_move(
-                self.index_of_edit, self.spline_edit, self.x, self.y, difs)
+            self.points.updates_for_mouse_move(self.index_of_edit,
+                                               self.spline_edit, self.mousex,
+                                               self.mousey, difs)
 
     def export_json(self, file_name):
         self.path_to_export = os.path.join(
@@ -351,16 +284,12 @@
             get_json_folder(FIELD),  # path from the root
             file_name  # selected file
         )
-        if file_name[-5:] != ".json":
-            print("Error: Filename doesn't end in .json")
-        else:
-            # Will export to json file
-            self.mode = Mode.kEditing
 
-            multi_spline = self.points.toMultiSpline()
-            print(multi_spline)
-            with open(self.path_to_export, mode='w') as points_file:
-                json.dump(multi_spline, points_file)
+        # Will export to json file
+        multi_spline = self.points.toMultiSpline()
+        print(multi_spline)
+        with open(self.path_to_export, mode='w') as points_file:
+            json.dump(multi_spline, points_file)
 
     def import_json(self, file_name):
         self.path_to_export = os.path.join(
@@ -370,47 +299,37 @@
             file_name  # selected file
         )
 
-        if file_name[-5:] != ".json":
-            print("Error: Filename doesn't end in .json")
-        else:
-            # import from json file
-            self.mode = Mode.kEditing
-            print("LOADING LOAD FROM " + file_name)  # Load takes a few seconds
-            with open(self.path_to_export) as points_file:
-                multi_spline = json.load(points_file)
+        # import from json file
+        print("LOADING LOAD FROM " + file_name)  # Load takes a few seconds
+        with open(self.path_to_export) as points_file:
+            multi_spline = json.load(points_file)
 
-            # if people messed with the spline json,
-            # it might not be the right length
-            # so give them a nice error message
-            try:  # try to salvage as many segments of the spline as possible
-                self.points.fromMultiSpline(multi_spline)
-            except IndexError:
-                # check if they're both 6+5*(k-1) long
-                expected_length = 6 + 5 * (multi_spline["spline_count"] - 1)
-                x_len = len(multi_spline["spline_x"])
-                y_len = len(multi_spline["spline_x"])
-                if x_len is not expected_length:
-                    print(
-                        "Error: spline x values were not the expected length; expected {} got {}"
-                        .format(expected_length, x_len))
-                elif y_len is not expected_length:
-                    print(
-                        "Error: spline y values were not the expected length; expected {} got {}"
-                        .format(expected_length, y_len))
+        # if people messed with the spline json,
+        # it might not be the right length
+        # so give them a nice error message
+        try:  # try to salvage as many segments of the spline as possible
+            self.points.fromMultiSpline(multi_spline)
+        except IndexError:
+            # check if they're both 6+5*(k-1) long
+            expected_length = 6 + 5 * (multi_spline["spline_count"] - 1)
+            x_len = len(multi_spline["spline_x"])
+            y_len = len(multi_spline["spline_x"])
+            if x_len is not expected_length:
+                print(
+                    "Error: spline x values were not the expected length; expected {} got {}"
+                    .format(expected_length, x_len))
+            elif y_len is not expected_length:
+                print(
+                    "Error: spline y values were not the expected length; expected {} got {}"
+                    .format(expected_length, y_len))
 
-            print("SPLINES LOADED")
+        print("SPLINES LOADED")
+        self.mode = Mode.kEditing
 
-    def do_key_press(self, event, file_name):
+    def key_press(self, event, file_name):
         keyval = Gdk.keyval_to_lower(event.keyval)
-        if keyval == Gdk.KEY_q:
-            print("Found q key and exiting.")
-            quit_main_loop()
-        if keyval == Gdk.KEY_e:
-            export_json(file_name)
 
-        if keyval == Gdk.KEY_i:
-            import_json(file_name)
-
+        # TODO: This should be a button
         if keyval == Gdk.KEY_p:
             self.mode = Mode.kPlacing
             # F0 = A1
@@ -423,16 +342,19 @@
                 self.points.getSplines()[len(self.points.getSplines()) - 1][4],
                 self.points.getSplines()[len(self.points.getSplines()) - 1][3])
 
-    def button_press_action(self):
+    def button_press(self, event):
+        self.mousex = event.x
+        self.mousey = event.y
+
         if self.mode == Mode.kPlacing:
-            if self.points.add_point(self.x, self.y):
+            if self.points.add_point(self.mousex, self.mousey):
                 self.mode = Mode.kEditing
         elif self.mode == Mode.kEditing:
             # Now after index_of_edit is not -1, the point is selected, so
             # user can click for new point
-            if self.index_of_edit > -1 and self.held_x != self.x:
+            if self.index_of_edit > -1 and self.held_x != self.mousex:
                 self.points.setSplines(self.spline_edit, self.index_of_edit,
-                                       pxToM(self.x), pxToM(self.y))
+                                       pxToM(self.mousex), pxToM(self.mousey))
 
                 self.points.splineExtrapolate(self.spline_edit)
 
@@ -442,7 +364,7 @@
                 # Get clicked point
                 # Find nearest
                 # Move nearest to clicked
-                cur_p = [pxToM(self.x), pxToM(self.y)]
+                cur_p = [pxToM(self.mousex), pxToM(self.mousey)]
                 # Get the distance between each for x and y
                 # Save the index of the point closest
                 nearest = 1  # Max distance away a the selected point can be in meters
@@ -459,10 +381,4 @@
                             print("Index: " + str(index_of_closest))
                             self.index_of_edit = index_of_closest
                             self.spline_edit = index_splines
-                            self.held_x = self.x
-
-    def do_button_press(self, event):
-        # Be consistent with the scaling in the drawing_area
-        self.x = event.x * 2 - mToPx(FIELD.width / 2.0)
-        self.y = event.y * 2
-        self.button_press_action()
+                            self.held_x = self.mousex
diff --git a/frc971/control_loops/python/spline_graph.py b/frc971/control_loops/python/spline_graph.py
index 347837b..ad3ae96 100755
--- a/frc971/control_loops/python/spline_graph.py
+++ b/frc971/control_loops/python/spline_graph.py
@@ -1,12 +1,16 @@
 #!/usr/bin/python3
+
+# matplotlib overrides fontconfig locations, so has to be imported before gtk
+import matplotlib
 import gi
-from path_edit import *
-import numpy as np
+from path_edit import FieldWidget
+from basic_window import RunApp
+from constants import FIELDS, FIELD, SCREEN_SIZE
 gi.require_version('Gtk', '3.0')
 from gi.repository import Gdk, Gtk, GLib
 import cairo
 import basic_window
-
+import os
 
 class GridWindow(Gtk.Window):
     def method_connect(self, event, cb):
@@ -16,99 +20,68 @@
         self.connect(event, handler)
 
     def mouse_move(self, event):
-        # Changes event.x and event.y to be relative to the center.
-        x = event.x - self.drawing_area.window_shape[0] / 2
-        y = self.drawing_area.window_shape[1] / 2 - event.y
-        scale = self.drawing_area.get_current_scale()
-        event.x = x / scale + self.drawing_area.center[0]
-        event.y = y / scale + self.drawing_area.center[1]
-        self.drawing_area.mouse_move(event)
+        self.field.mouse_move(event)
         self.queue_draw()
 
     def button_press(self, event):
-        original_x = event.x
-        original_y = event.y
-        x = event.x - self.drawing_area.window_shape[0] / 2
-        y = self.drawing_area.window_shape[1] / 2 - event.y
-        scale = 2 * self.drawing_area.get_current_scale()
-        event.x = x / scale + self.drawing_area.center[0]
-        event.y = y / scale + self.drawing_area.center[1]
-        self.drawing_area.do_button_press(event)
-        event.x = original_x
-        event.y = original_y
+        self.field.button_press(event)
 
     def key_press(self, event):
-        self.drawing_area.do_key_press(event, self.file_name_box.get_text())
+        self.field.key_press(event, self.file_name_box.get_text())
         self.queue_draw()
 
     def configure(self, event):
-        self.drawing_area.window_shape = (event.width, event.height)
+        self.field.window_shape = (event.width, event.height)
 
     def output_json_clicked(self, button):
-        print("OUTPUT JSON CLICKED")
-        self.drawing_area.export_json(self.file_name_box.get_text())
+        self.field.export_json(self.file_name_box.get_text())
 
     def input_json_clicked(self, button):
-        print("INPUT JSON CLICKED")
-        self.drawing_area.import_json(self.file_name_box.get_text())
+        self.field.import_json(self.file_name_box.get_text())
         self.long_input.set_value(
-            self.drawing_area.points.getConstraint(
-                "LONGITUDINAL_ACCELERATION"))
+            self.field.points.getConstraint("LONGITUDINAL_ACCELERATION"))
         self.lat_input.set_value(
-            self.drawing_area.points.getConstraint("LATERAL_ACCELERATION"))
-        self.vol_input.set_value(
-            self.drawing_area.points.getConstraint("VOLTAGE"))
+            self.field.points.getConstraint("LATERAL_ACCELERATION"))
+        self.vol_input.set_value(self.field.points.getConstraint("VOLTAGE"))
 
     def long_changed(self, button):
         value = self.long_input.get_value()
-        self.drawing_area.points.setConstraint("LONGITUDINAL_ACCELERATION",
-                                               value)
+        self.field.points.setConstraint("LONGITUDINAL_ACCELERATION", value)
 
     def lat_changed(self, button):
         value = self.lat_input.get_value()
-        self.drawing_area.points.setConstraint("LATERAL_ACCELERATION", value)
+        self.field.points.setConstraint("LATERAL_ACCELERATION", value)
 
     def vel_changed(self, button):
         value = self.vel_input.get_value()
 
     def vol_changed(self, button):
         value = self.vol_input.get_value()
-        self.drawing_area.points.setConstraint("VOLTAGE", value)
+        self.field.points.setConstraint("VOLTAGE", value)
 
     def input_combobox_choice(self, combo):
         text = combo.get_active_text()
         if text is not None:
             print("Combo Clicked on: " + text)
-            set_field(text)
+            #set_field(text)
 
     def __init__(self):
         Gtk.Window.__init__(self)
 
         self.set_default_size(1.5 * SCREEN_SIZE, SCREEN_SIZE)
 
-        flowBox = Gtk.FlowBox()
-        flowBox.set_valign(Gtk.Align.START)
-        flowBox.set_selection_mode(Gtk.SelectionMode.NONE)
-
-        flowBox.set_valign(Gtk.Align.START)
-
-        self.add(flowBox)
-
-        container = Gtk.Fixed()
-        flowBox.add(container)
+        container = Gtk.Grid()
+        container.set_vexpand(True)
+        self.add(container)
 
         self.eventBox = Gtk.EventBox()
-        container.add(self.eventBox)
-
         self.eventBox.set_events(Gdk.EventMask.BUTTON_PRESS_MASK
                                  | Gdk.EventMask.BUTTON_RELEASE_MASK
                                  | Gdk.EventMask.POINTER_MOTION_MASK
                                  | Gdk.EventMask.SCROLL_MASK
                                  | Gdk.EventMask.KEY_PRESS_MASK)
 
-        #add the graph box
-        self.drawing_area = GTK_Widget()
-        self.eventBox.add(self.drawing_area)
+        self.field = FieldWidget()
 
         self.method_connect("delete-event", basic_window.quit_main_loop)
         self.method_connect("key-release-event", self.key_press)
@@ -118,12 +91,9 @@
 
         self.file_name_box = Gtk.Entry()
         self.file_name_box.set_size_request(200, 40)
-
         self.file_name_box.set_text(FIELD.field_id + ".json")
         self.file_name_box.set_editable(True)
 
-        container.put(self.file_name_box, 0, 0)
-
         self.long_input = Gtk.SpinButton()
         self.long_input.set_size_request(100, 20)
         self.long_input.set_numeric(True)
@@ -134,8 +104,7 @@
         self.long_label = Gtk.Label()
         self.long_label.set_text("Longitudinal Acceleration Restriction")
         self.long_input.set_value(
-            self.drawing_area.points.getConstraint(
-                "LONGITUDINAL_ACCELERATION"))
+            self.field.points.getConstraint("LONGITUDINAL_ACCELERATION"))
 
         self.lat_input = Gtk.SpinButton()
         self.lat_input.set_size_request(100, 20)
@@ -147,7 +116,7 @@
         self.lat_label = Gtk.Label()
         self.lat_label.set_text("Lateral Acceleration Restriction")
         self.lat_input.set_value(
-            self.drawing_area.points.getConstraint("LATERAL_ACCELERATION"))
+            self.field.points.getConstraint("LATERAL_ACCELERATION"))
 
         self.vel_input = Gtk.SpinButton()
         self.vel_input.set_size_request(100, 20)
@@ -170,19 +139,9 @@
         self.vol_input.connect("value-changed", self.vol_changed)
         self.vol_label = Gtk.Label()
         self.vol_label.set_text("Voltage Restriction")
-        self.vol_input.set_value(
-            self.drawing_area.points.getConstraint("VOLTAGE"))
+        self.vol_input.set_value(self.field.points.getConstraint("VOLTAGE"))
 
-        container.put(self.long_input, 0, 60)
-        container.put(self.lat_input, 0, 110)
-        container.put(self.vel_input, 0, 160)
-        container.put(self.vol_input, 0, 210)
-        container.put(self.long_label, 0, 40)
-        container.put(self.lat_label, 0, 90)
-        container.put(self.vel_label, 0, 140)
-        container.put(self.vol_label, 0, 190)
-
-        self.output_json = Gtk.Button.new_with_label("Output")
+        self.output_json = Gtk.Button.new_with_label("Export")
         self.output_json.set_size_request(100, 40)
         self.output_json.connect("clicked", self.output_json_clicked)
 
@@ -190,40 +149,57 @@
         self.input_json.set_size_request(100, 40)
         self.input_json.connect("clicked", self.input_json_clicked)
 
-        container.put(self.output_json, 210, 0)
-        container.put(self.input_json, 320, 0)
-
-
         #Dropdown feature
-        self.label = Gtk.Label("Change Map:")
-        self.label.set_size_request(100,40)
-        container.put(self.label,430,0)
+        self.label = Gtk.Label()
+        self.label.set_text("Change Field:")
+        self.label.set_size_request(100, 40)
 
         game_store = Gtk.ListStore(str)
-        games = [
-           "2020 Field",
-           "2019 Field",
-           "2021 Galactic Search ARed",
-           "2021 Galactic Search ABlue",
-           "2021 Galactic Search BRed",
-           "2021 Galactic Search BBlue",
-           "2021 AutoNav Barrel Racing",
-           "2021 AutoNav Slalom",
-           "2021 AutoNav Bounce",
-           ]
 
         self.game_combo = Gtk.ComboBoxText()
         self.game_combo.set_entry_text_column(0)
         self.game_combo.connect("changed", self.input_combobox_choice)
 
-        for game in games:
-          self.game_combo.append_text(game)
+        for game in FIELDS.keys():
+            self.game_combo.append_text(game)
 
         self.game_combo.set_active(0)
-        self.game_combo.set_size_request(100,40)
-        container.put(self.game_combo,440,30)
+        self.game_combo.set_size_request(100, 40)
+
+        limitControls = Gtk.FlowBox()
+        limitControls.set_min_children_per_line(1)
+        limitControls.set_max_children_per_line(2)
+        limitControls.add(self.long_label)
+        limitControls.add(self.long_input)
+
+        limitControls.add(self.lat_label)
+        limitControls.add(self.lat_input)
+
+        limitControls.add(self.vel_label)
+        limitControls.add(self.vel_input)
+
+        limitControls.add(self.vol_label)
+        limitControls.add(self.vol_input)
+
+        container.attach(limitControls, 5, 1, 1, 1)
+
+        jsonControls = Gtk.FlowBox()
+        jsonControls.set_min_children_per_line(3)
+        jsonControls.add(self.file_name_box)
+        jsonControls.add(self.output_json)
+        jsonControls.add(self.input_json)
+        container.attach(jsonControls, 1, 0, 1, 1)
+
+        container.attach(self.label, 4, 0, 1, 1)
+        container.attach(self.game_combo, 5, 0, 1, 1)
+
+        self.eventBox.add(self.field)
+        container.attach(self.eventBox, 1, 1, 4, 4)
+
+        container.attach(self.field.graph, 0, 10, 10, 1)
 
         self.show_all()
 
+
 window = GridWindow()
 RunApp()