gethub n02

i

mport math
	from string import join
	import time
	import ExcellonReader
	import GerberReader3
	from wxGerberCanvas import GerberCanvas
	from GerberReader3 import load_file, GerberLayer, GerberData
	import pyclipper
	import wx
	import wx.grid
	import wx.lib.scrolledpanel
	import wx.lib.agw.pycollapsiblepane as PCP
	__author__ = 'Damien, Ben, Thompson'
	VERSION = "V5.5"
	DATE = "02/12/15"
	def sizedToFill(content, margin=0):
	"""
	Utility method to add a sizer that fills the whole parent with the content pane
	:param content:
	:return:
	"""
	sizer = wx.BoxSizer(wx.VERTICAL)
	if margin == 0:
	sizer.Add(content, 0, wx.EXPAND)
	else:
	sizer.Add(content, 0, wx.EXPAND | wx.ALL, margin)
	content.GetParent().SetSizer(sizer)
	class DeviceProfile():
	def __init__(self, name,
	tooldiameter = None,
	feedrate = None,
	spindlespeed = None,
	toolcode = None,
	coolant = None,
	zup = None,
	zdown = None):
	self.name = name
	self.tooldiameter = tooldiameter
	self.feedrate = feedrate
	self.spindlespeed = spindlespeed
	self.toolcode = toolcode
	self.coolant = coolant
	self.zup = zup
	self.zdown = zdown
	class MyPopupMenu(wx.Menu):
	def __init__(self, lazorApp, pos):
	wx.Menu.__init__(self)
	self.pos = pos
	self.lazorApp = lazorApp
	""" :type lazorApp: LazorAppFrame """
	item = wx.MenuItem(self, wx.NewId(), "Set measuring point")
	self.AppendItem(item)
	self.Bind(wx.EVT_MENU, self.OnItem1, item)
	item = wx.MenuItem(self, wx.NewId(), "Cancel measurement")
	self.AppendItem(item)
	self.Bind(wx.EVT_MENU, self.OnItem2, item)
	self.AppendSeparator()
	item = wx.MenuItem(self, wx.NewId(),"Set custom origin")
	self.AppendItem(item)
	self.Bind(wx.EVT_MENU, self.OnItem3, item)
	def OnItem1(self, event):
	self.lazorApp.canvas.startMeasurement(self.pos)
	def OnItem2(self, event):
	self.lazorApp.canvas.stopMeasurement()
	def OnItem3(self, event):
	self.lazorApp.setCustomOrigin(self.pos)
	class LazorAppFrame(wx.Frame):
	""" Main App frame"""
	deviceProfiles = [DeviceProfile("g: g code file", "0.008", "100", "1000", "1", False, "0.05", "-0.005"),
	DeviceProfile("l: LaZoR code file", "0.004", "100", "100", "1", False, None, None)]
	def __init__(self, parent=None):
	super(LazorAppFrame, self).__init__(parent, title="LaZoR",
	size=(800, 600),
	style=wx.DEFAULT_FRAME_STYLE|wx.NO_FULL_REPAINT_ON_RESIZE)
	# Create status bar
	self.CreateStatusBar()
	self.GetStatusBar().SetFieldsCount(4)
	self.SetStatusWidths([-1, 125, 125, 125])
	# Setting up the menu.
	self.loadMenu()
	# Set up frame contents
	self.canvas = canvas = GerberCanvas(self, self.GetStatusBar(), 1) # shows gerber data
	canvas.Bind(wx.EVT_RIGHT_UP, self.OnRightClick, canvas)
	toolapanel = self.loadToolsPanel()
	self.layersPanel = layersPanel = LayersPanel(self)
	layersPanel.loadLayersPanel(None, self.NotifyDataChange)
	self.sizerH1 = sizerH1 = wx.BoxSizer(wx.HORIZONTAL)
	sizerH1.Add(toolapanel, 0, wx.EXPAND)
	sizerH1.Add(canvas, 1, wx.EXPAND)
	sizerH1.Add(layersPanel, 0, wx.EXPAND)
	self.SetSizer(sizerH1)
	self.SetAutoLayout(True)
	sizerH1.Fit(self)
	# Initialise variables
	self.contours = None
	self.boundarys = None
	self.pcb_edges = None
	self.data = None
	""" :type data: GerberData """
	def loadMenu(self):
	filemenu = wx.Menu()
	menuAbout = filemenu.Append(wx.ID_ABOUT, "&About"," Information about this program")
	filemenu.AppendSeparator()
	menuExit = filemenu.Append(wx.ID_EXIT,"E&xit"," Terminate the program")
	filemenu2 = wx.Menu()
	zoomin = filemenu2.Append(wx.ID_ANY, "Zoom In")
	zoomout = filemenu2.Append(wx.ID_ANY, "Zoom Out")
	menuFitToView = filemenu2.Append(wx.ID_ANY, "Fit to View")
	filemenu2.AppendSeparator()
	self.menuLayerEditor = filemenu2.AppendCheckItem(wx.ID_ANY, "Show/Hide layer editor")
	filemenu2.Check(self.menuLayerEditor.GetId(), True)
	# Create the menubar.
	menuBar = wx.MenuBar()
	menuBar.Append(filemenu,"&File")
	menuBar.Append(filemenu2, "&View")
	self.SetMenuBar(menuBar)
	# Set events.
	self.Bind(wx.EVT_MENU, self.OnAbout, menuAbout)
	self.Bind(wx.EVT_MENU, self.OnExit, menuExit)
	self.Bind(wx.EVT_MENU, self.OnShowHideLayerEditor, self.menuLayerEditor)
	self.Bind(wx.EVT_MENU, self.OnZoomIn, zoomin)
	self.Bind(wx.EVT_MENU, self.OnZoomOut, zoomout)
	self.Bind(wx.EVT_MENU, self.OnFitToView, menuFitToView)
	def loadToolsPanel(self):
	panel = wx.lib.scrolledpanel.ScrolledPanel(self, size=(300, 0))
	sizer = wx.BoxSizer(wx.VERTICAL)
	sizerH1 = wx.BoxSizer(wx.HORIZONTAL)
	sizerH1.Add(wx.StaticText(panel, -1, "Units: "), 0, wx.FIXED | wx.TOP | wx.RIGHT, 3)
	self.unitcombo = wx.ComboBox(panel, -1, "in", choices=["mm","in"], style=wx.CB_READONLY)
	self.Bind(wx.EVT_COMBOBOX, self.hdl)
	sizerH1.Add(self.unitcombo, 0, wx.FIXED | wx.ALIGN_BOTTOM)
	self.nativeLabel = wx.StaticText(panel, -1)
	sizerH1.AddSpacer(10)
	sizerH1.Add(self.nativeLabel, 0, wx.FIXED | wx.TOP, 3)
	sizer.Add(sizerH1, 0, wx.EXPAND | wx.ALL, 10)
	deviceNames = []
	for dp in self.deviceProfiles: deviceNames.append(dp.name)
	self.devicecombo = wx.ComboBox(panel, -1, deviceNames[0], style=wx.CB_READONLY, choices=deviceNames)
	fontMono = self.devicecombo.GetFont()
	fontMono = wx.Font(fontMono.GetPointSize(), wx.TELETYPE,
	fontMono.GetStyle(),
	fontMono.GetWeight(), fontMono.GetUnderlined())
	self.devicecombo.SetFont(fontMono)
	self.Bind(wx.EVT_COMBOBOX, self.OnDeviceCombo, self.devicecombo)
	sizerH2 = wx.BoxSizer(wx.HORIZONTAL)
	sizerH2.Add(wx.StaticText(panel, -1, "Output device: "), 0, wx.EXPAND | wx.TOP | wx.RIGHT, 4)
	sizerH2.Add(self.devicecombo, 0, wx.FIXED)
	sizer.Add(sizerH2, 0, wx.EXPAND | wx.ALL, 10)
	cp = PCP.PyCollapsiblePane(panel, label="Import Data", agwStyle=wx.CP_NO_TLW_RESIZE)
	self.Bind(wx.EVT_COLLAPSIBLEPANE_CHANGED, self.OnPaneChanged, cp)
	self.loadToolsImportPanel(cp.GetPane())
	sizer.Add(cp, 0, wx.EXPAND)
	cp.Expand()
	cp = PCP.PyCollapsiblePane(panel, label="Isolation Workbench", agwStyle=wx.CP_NO_TLW_RESIZE)
	self.Bind(wx.EVT_COLLAPSIBLEPANE_CHANGED, self.OnPaneChanged, cp)
	self.loadToolsIsolationPanel(cp.GetPane())
	sizer.Add(cp, 0, wx.EXPAND)
	cp = PCP.PyCollapsiblePane(panel, label="Drill Workbench", agwStyle=wx.CP_NO_TLW_RESIZE)
	self.Bind(wx.EVT_COLLAPSIBLEPANE_CHANGED, self.OnPaneChanged, cp)
	self.loadToolsDrillPanel(cp.GetPane())
	sizer.Add(cp, 0, wx.EXPAND)
	cp = PCP.PyCollapsiblePane(panel, label="Edge Workbench", agwStyle=wx.CP_NO_TLW_RESIZE)
	self.Bind(wx.EVT_COLLAPSIBLEPANE_CHANGED, self.OnPaneChanged, cp)
	self.loadToolsEdgePanel(cp.GetPane())
	sizer.Add(cp, 0, wx.EXPAND)
	self.OnDeviceCombo(0)
	panel.SetSizer(sizer)
	panel.SetAutoLayout(True)
	panel.SetupScrolling(False, True, scrollIntoView=False)
	return panel
	def loadToolsImportPanel(self, parent):
	panel = wx.Panel(parent)
	sizer = wx.BoxSizer(wx.VERTICAL)
	button1 = wx.Button(panel, -1, "Load Gerber")
	sizer.Add(button1, 0, wx.EXPAND | wx.ALL, 5)
	button2 = wx.Button(panel, -1, "Load Edge")
	sizer.Add(button2, 0, wx.EXPAND | wx.ALL, 5)
	button3 = wx.Button(panel, -1, "Load Drill")
	sizer.Add(button3, 0, wx.EXPAND | wx.ALL, 5)
	button4 = wx.Button(panel, -1, "Clear Drill Data")
	sizer.Add(button4, 0, wx.EXPAND | wx.ALL, 5)
	panel.Bind(wx.EVT_BUTTON, self.LoadGerberFile, button1)
	panel.Bind(wx.EVT_BUTTON, self.LoadEdgeFile, button2)
	panel.Bind(wx.EVT_BUTTON, self.LoadDrillFile, button3)
	panel.Bind(wx.EVT_BUTTON, self.ClearDrillData, button4)
	panel.SetSizer(sizer)
	sizedToFill(panel)
	return panel
	def loadToolsIsolationPanel(self, parent):
	panel = wx.Panel(parent)
	sizer = wx.FlexGridSizer(20, 2, 4, 0)
	sizer.AddGrowableCol(1, 1)
	sizer.SetFlexibleDirection(wx.VERTICAL)
	button1 = wx.Button(panel, -1, "Contour")
	button2 = wx.Button(panel, -1, "Raster")
	button3 = wx.Button(panel, -1, "Clear")
	panel.Bind(wx.EVT_BUTTON, self.addContour, button1)
	panel.Bind(wx.EVT_BUTTON, self.addToolpath, button2)
	panel.Bind(wx.EVT_BUTTON, self.clearToolpath, button3)
	self.showcutwidthcheckbox = wx.CheckBox(panel, -1, "Show cut-width")
	panel.Bind(wx.EVT_CHECKBOX, self.OnUpdateShowCutWidth, self.showcutwidthcheckbox)
	self.tooldiainput = wx.TextCtrl(panel, -1, "0.2")
	self.tooldiainput.SetToolTip(wx.ToolTip("Tool diameter using in units specified at top"))
	self.ncontourinput = wx.TextCtrl(panel, -1, "1")
	self.ncontourinput.SetToolTip(wx.ToolTip("Number of contours as positive integer"))
	self.contourundercutinput = wx.TextCtrl(panel, -1, "0.8")
	self.contourundercutinput.SetToolTip(wx.ToolTip("Contour overlap as decimal proportion"))
	self.rasteroverlapinput = wx.TextCtrl(panel, -1, "0.8")
	self.rasteroverlapinput.SetToolTip(wx.ToolTip("Raster overlap as decimal proportion"))
	sizer.Add(wx.StaticText(panel, -1, "Tool diameter"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.tooldiainput, 0, wx.EXPAND)
	sizer.Add(wx.StaticText(panel, -1, "N contour"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.ncontourinput, 0, wx.EXPAND)
	sizer.Add(wx.StaticText(panel, -1, "Contour undercut"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.contourundercutinput, 0, wx.EXPAND)
	sizer.Add(wx.StaticText(panel, -1, "Raster overlap"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.rasteroverlapinput, 0, wx.EXPAND)
	sizer.AddSpacer(0)
	sizer.Add(self.showcutwidthcheckbox, 0, wx.EXPAND)
	sizer.AddSpacer(0)
	sizer.Add(button1, 0, wx.FIXED)
	sizer.AddSpacer(0)
	sizer.Add(button2, 0, wx.FIXED)
	sizer.AddSpacer(0)
	sizer.Add(button3, 0, wx.FIXED)
	sizer.AddSpacer(1)
	sizer.AddSpacer(1)
	button1 = wx.Button(panel, -1, "Output File")
	button2 = wx.Button(panel, -1, "Write Toolpath")
	panel.Bind(wx.EVT_BUTTON, self.OnChooseOutputFile, button1)
	panel.Bind(wx.EVT_BUTTON, self.OnWriteToolpath, button2)
	self.feedrateinput = wx.TextCtrl(panel, -1, "100")
	self.spindlespeedinput = wx.TextCtrl(panel, -1, "1000")
	self.toolinput = wx.TextCtrl(panel, -1, "1")
	self.zupinput = wx.TextCtrl(panel, -1, "0.05")
	self.zdowninput = wx.TextCtrl(panel, -1, "-0.005")
	self.fileoutputinput = wx.TextCtrl(panel, -1, "out.g")
	self.coolantcheckbox = wx.CheckBox(panel, -1, "Coolant")
	self.origincombo = wx.ComboBox(panel, -1, style=wx.CB_READONLY,
	choices=["File Origin", "Centre", "Top Left", "Bottom Left", "Top Right", "Bottom Right", "Custom"])
	# The last of origin combo choices MUST be custom.
	self.origincombo.SetSelection(0)
	self.Bind(wx.EVT_COMBOBOX, self.OnOriginChoose, self.origincombo)
	sizer.Add(wx.StaticText(panel, -1, "Output origin"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.origincombo, 0, wx.EXPAND)
	sizer.Add(wx.StaticText(panel, -1, "Feed rate"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.feedrateinput, 0, wx.EXPAND)
	sizer.Add(wx.StaticText(panel, -1, "Spindle speed"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.spindlespeedinput, 0, wx.EXPAND)
	sizer.Add(wx.StaticText(panel, -1, "Tool"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.toolinput, 0, wx.EXPAND)
	sizer.AddSpacer(0)
	sizer.Add(self.coolantcheckbox, 0, wx.EXPAND)
	sizer.Add(wx.StaticText(panel, -1, "Z up"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.zupinput, 0, wx.EXPAND)
	sizer.Add(wx.StaticText(panel, -1, "Z down"), 0, wx.EXPAND | wx.TOP, 4)
	sizer.Add(self.zdowninput, 0, wx.EXPAND)
	sizer.Add(button1, 0, wx.EXPAND | wx.RIGHT, 4)
	sizer.Add(self.fileoutputinput, 0, wx.EXPAND)
	sizer.AddSpacer(0)
	sizer.Add(button2, 0, wx.EXPAND)
	panel.SetSizer(sizer)
	panel.SetAutoLayout(True)
	sizedToFill(panel, 12)
	return panel
	def loadToolsDrillPanel(self, parent):
	panel = wx.Panel(parent)
	sizer = wx.FlexGridSizer(5, 2, 4, 4)
	sizer.AddGrowableCol(1, 1)
	sizer.SetFlexibleDirection(wx.BOTH)
	# button1 = wx.Button(panel, -1, "Output File")
	# button2 = wx.Button(panel, -1, "Write Toolpath")
	# panel.Bind(wx.EVT_BUTTON, self.OnChooseOutputFile, button1)
	# panel.Bind(wx.EVT_BUTTON, self.OnWriteToolpath, button2)
	#
	# self.feedrateinput = wx.TextCtrl(panel, -1, "100")
	# self.spindlespeedinput = wx.TextCtrl(panel, -1, "1000")
	# self.toolinput = wx.TextCtrl(panel, -1, "1")
	# self.zupinput = wx.TextCtrl(panel, -1, "0.05")
	# self.zdowninput = wx.TextCtrl(panel, -1, "-0.005")
	# self.fileoutputinput = wx.TextCtrl(panel, -1, "out.g")
	#
	# self.coolantcheckbox = wx.CheckBox(panel, -1, "Coolant")
	#
	# self.origincombo = wx.ComboBox(panel, -1, style=wx.CB_READONLY,
	# choices=["File Origin", "Centre", "Top Left", "Bottom Left", "Top Right", "Bottom Right", "Custom"])
	# self.origincombo.SetSelection(0)
	# self.Bind(wx.EVT_COMBOBOX, self.OnOriginChoose, self.origincombo)
	#
	# sizer.Add(wx.StaticText(panel, -1, "Output origin"), 0, wx.EXPAND | wx.TOP, 4)
	# sizer.Add(self.origincombo, 0, wx.EXPAND)
	# sizer.Add(wx.StaticText(panel, -1, "Feed rate"), 0, wx.EXPAND | wx.TOP, 4)
	# sizer.Add(self.feedrateinput, 0, wx.EXPAND)
	# sizer.Add(wx.StaticText(panel, -1, "Spindle speed"), 0, wx.EXPAND | wx.TOP, 4)
	# sizer.Add(self.spindlespeedinput, 0, wx.EXPAND)
	# sizer.Add(wx.StaticText(panel, -1, "Tool"), 0, wx.EXPAND | wx.TOP, 4)
	# sizer.Add(self.toolinput, 0, wx.EXPAND)
	# sizer.AddSpacer(0)
	# sizer.Add(self.coolantcheckbox, 0, wx.EXPAND)
	# sizer.Add(wx.StaticText(panel, -1, "Z up"), 0, wx.EXPAND | wx.TOP, 4)
	# sizer.Add(self.zupinput, 0, wx.EXPAND)
	# sizer.Add(wx.StaticText(panel, -1, "Z down"), 0, wx.EXPAND | wx.TOP, 4)
	# sizer.Add(self.zdowninput, 0, wx.EXPAND)
	# sizer.Add(button1, 0, wx.EXPAND)
	# sizer.Add(self.fileoutputinput, 0, wx.EXPAND)
	# sizer.AddSpacer(0)
	# sizer.Add(button2, 0, wx.EXPAND)
	panel.SetSizer(sizer)
	panel.SetAutoLayout(True)
	sizedToFill(panel, 12)
	return panel
	def loadToolsEdgePanel(self, parent):
	panel = wx.Panel(parent)
	sizer = wx.FlexGridSizer(5, 2, 4, 4)
	sizer.AddGrowableCol(1, 1)
	sizer.SetFlexibleDirection(wx.BOTH)
	panel.SetSizer(sizer)
	panel.SetAutoLayout(True)
	sizedToFill(panel, 12)
	return panel
	def hdl(self, evt):
	self.canvas.setUnit(self.unitcombo.GetCurrentSelection())
	def OnAbout(self, evt):
	dlg = wx.MessageDialog( self, join(["LaZoR ", VERSION, "\n", DATE]), "About", wx.OK)
	dlg.ShowModal()
	dlg.Destroy()
	def OnExit(self, evt):
	self.Close(True)
	def OnZoomIn(self, evt):
	self.canvas.zoomrel(1.25)
	def OnZoomOut(self, evt):
	self.canvas.zoomrel(1 / 1.25)
	def OnFitToView(self, evt):
	if self.data is None: return
	self.canvas.autoscale_cac()
	self.canvas.Refresh()
	def OnShowHideLayerEditor(self, evt):
	if self.menuLayerEditor.IsChecked():
	self.layersPanel.Show()
	else:
	self.layersPanel.Hide()
	self.layersPanel.GetParent().Layout()
	def OnPaneChanged(self, evt):
	self.Layout()
	self.Refresh()
	def OnChooseOutputFile(self, evt):
	dlg = wx.FileDialog(self, "Choose g-code output file", "", "",
	"All Files (*.*)|*",
	wx.FD_SAVE)
	if dlg.ShowModal() == wx.ID_CANCEL: return
	self.fileoutputinput.SetValue(dlg.GetPath())
	dlg.Destroy()
	def OnDeviceCombo(self, evt):
	dp = self.deviceProfiles[self.devicecombo.GetSelection()]
	self.setComp(self.tooldiainput, dp.tooldiameter)
	self.setComp(self.feedrateinput, dp.feedrate)
	self.setComp(self.spindlespeedinput, dp.spindlespeed)
	self.setComp(self.toolinput, dp.toolcode)
	self.setComp(self.zupinput, dp.zup)
	self.setComp(self.zdowninput, dp.zdown)
	if dp.coolant is None:
	self.coolantcheckbox.SetValue(False)
	self.coolantcheckbox.Disable()
	else:
	self.coolantcheckbox.Enable()
	self.coolantcheckbox.SetValue(dp.coolant)
	self.contours = []
	self.contoolpaths = []
	self.canvas.toolpaths = []
	self.canvas.updateToolpathData()
	self.NotifyDataChange()
	def OnWriteToolpath(self, evt):
	# TODO: should be more generic than this
	if self.devicecombo.GetSelection() == 0:
	self.write_G()
	else:
	self.write_l()
	def OnOriginChoose(self, evt):
	if self.data is None: return
	choice = self.origincombo.GetSelection()
	# "File Origin", "Centre", "Top Left", "Bottom Left", "Top Right", "Bottom Right", "Custom"
	data = self.data
	if choice == 0: # file origin
	data.originx = 0
	data.originy = 0
	elif choice == 1: # centre
	data.originx = (data.xmax + data.xmin) / 2.0
	data.originy = (data.ymax + data.ymin) / 2.0
	elif choice == 2: # top left
	data.originx = data.xmin
	data.originy = data.ymax
	elif choice == 3: # bottom left
	data.originx = data.xmin
	data.originy = data.ymin
	elif choice == 4: # top right
	data.originx = data.xmax
	data.originy = data.ymax
	elif choice == 5: # bottom right
	data.originx = data.xmax
	data.originy = data.ymin
	elif choice == 6: # custom
	return
	self.NotifyDataChange()
	def OnRightClick(self, evt):
	if self.data is None: return
	menu = MyPopupMenu(self, evt.GetPosition())
	self.canvas.PopupMenu(menu, evt.GetPosition())
	menu.Destroy()
	def setCustomOrigin(self, (mx, my)):
	x, y = self.canvas.GetViewStart()
	self.data.originx = self.canvas.MouseToInternalX(mx + x)
	self.data.originy = self.canvas.MouseToInternalY(my + y)
	self.origincombo.SetSelection(self.origincombo.GetCount() - 1) # set to custom option
	self.NotifyDataChange()
	def LoadGerberFile(self, evt):
	dlg = wx.FileDialog(self, "Open Gerber file", "", "",
	"Gerber Files (*.gbl;*.gtl;*.gbr;*.cmp)|*.gbl;*.gtl;*.gbr;*.cmp|All Files (*.*)|*",
	wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
	if dlg.ShowModal() == wx.ID_CANCEL:
	self.SetStatusText("Load Gerber file cancelled by user", 0)
	return
	filename = dlg.GetPath()
	dlg.Destroy()
	self.SetStatusText("Loading Gerber: " + filename + "...", 0)
	[data, tracks] = load_file(filename)
	self.data = data
	xmin = 1E99
	xmax = -1E99
	ymin = 1E99
	ymax = -1E99
	sum1 = 0
	sumReg = 0
	sumBound = 0
	sumTracks = 0
	sumPads = 0
	cbounds = pyclipper.Pyclipper()
	boundarys = []
	pcb_edges = []
	layers = list(data.layers)
	for gl in layers:
	if gl.type == GerberLayer.TYPE_PCBEDGE:
	data.layers.remove(gl)
	pcb_edges.extend(gl.points)
	for segment in gl.points:
	sum1 += len(segment)
	for vertex in segment:
	x = vertex[0]
	y = vertex[1]
	if x < xmin: xmin = x
	if x > xmax: xmax = x
	if y < ymin: ymin = y
	if y > ymax: ymax = y
	continue
	if gl.type == GerberLayer.TYPE_REGION:
	sumReg += len(gl.points)
	# regions.extend(gl.points)
	continue
	if gl.type == GerberLayer.TYPE_TRACK:
	sumTracks += len(gl.points)
	continue
	if gl.type == GerberLayer.TYPE_PAD:
	sumPads += len(gl.points)
	continue
	if gl.type == GerberLayer.TYPE_BOUNDARY:
	# if gl.isDark:
	# # boundarys.extend(gl.points)
	# # if len(boundarys) == 0:
	# boundarys.extend(gl.points)
	# # else:
	# # cbounds.AddPaths(boundarys, pyclipper.PT_SUBJECT)
	# # cbounds.AddPaths(gl.points, pyclipper.PT_SUBJECT)
	# # boundarys = cbounds.Execute(pyclipper.CT_UNION, pyclipper.PFT_EVENODD, pyclipper.PFT_EVENODD)
	# # cbounds.Clear()
	# else:
	# cbounds.AddPaths(boundarys, pyclipper.PT_SUBJECT)
	# cbounds.AddPaths(gl.points, pyclipper.PT_CLIP)
	# boundarys = cbounds.Execute(pyclipper.CT_DIFFERENCE, pyclipper.PFT_EVENODD, pyclipper.PFT_EVENODD)
	# cbounds.Clear()
	if gl.isDark:
	boundarys.extend(gl.points)
	else:
	cbounds.AddPaths(boundarys, pyclipper.PT_SUBJECT)
	cbounds.AddPaths(gl.points, pyclipper.PT_CLIP)
	boundarys = cbounds.Execute(pyclipper.CT_DIFFERENCE, pyclipper.PFT_NONZERO, pyclipper.PFT_NONZERO)
	cbounds.Clear()
	sumBound += len(gl.points)
	for segment in gl.points:
	sum1 += len(segment)
	for vertex in segment:
	x = vertex[0]
	y = vertex[1]
	if x < xmin: xmin = x
	if x > xmax: xmax = x
	if y < ymin: ymin = y
	if y > ymax: ymax = y
	continue
	if gl.type == GerberLayer.TYPE_MERGEDCOPPER:
	data.layers.remove(gl)
	continue
	print " fraction = ",self.data.fraction
	print " found", sumBound, "polygons,", sum1, "vertices"
	print " found", sumReg, "pours"
	print " found", sumTracks, "tracks"
	print " found", sumPads, "pads"
	print " found", len(pcb_edges), "edge segments"
	print " xmin: %0.3g " % xmin, "xmax: %0.3g " % xmax, "dx: %0.3g " % (xmax - xmin)
	print " ymin: %0.3g " % ymin, "ymax: %0.3g " % ymax, "dy: %0.3g " % (ymax - ymin)
	data.xmin2 = xmin
	data.xmax2 = xmax
	data.ymin2 = ymin
	data.ymax2 = ymax
	if len(pcb_edges) == 0:
	outer_offset = (1 if data.units == 0 else 0.03937) * 10**data.fraction # 1 mm
	# outer_offset = 0.01 * 10**data.fraction
	xmin -= outer_offset
	ymin -= outer_offset
	xmax += outer_offset
	ymax += outer_offset
	pcb_edge = [[xmax, ymax], [xmax, ymin], [xmin, ymin], [xmin, ymax], [xmax, ymax]]
	pcb_edges.append(pcb_edge)
	self.pcb_edges = pcb_edges
	self.boundarys = boundarys = pyclipper.SimplifyPolygons(boundarys, pyclipper.PFT_NONZERO)
	# boundarys = GerberReader3.replace_holes_with_seams(boundarys)
	GerberReader3.closeOffPolys(boundarys)
	data.layers.append(GerberLayer(True, "PCB Edge", pcb_edges, True, False, "blue", GerberLayer.TYPE_PCBEDGE))
	data.layers.append(GerberLayer(True, "Merged Copper", boundarys, False, color="brown", type=GerberLayer.TYPE_MERGEDCOPPER))
	# PCB bounds
	data.xmin = xmin
	data.xmax = xmax
	data.ymin = ymin
	data.ymax = ymax
	# View bounds
	# Includes the origin
	if xmin > 0: xmin = 0
	if xmax < 0: xmax = 0
	if ymin > 0: ymin = 0
	if ymax < 0: ymax = 0
	# Add margin
	ww = (xmax - xmin)*0.1
	hh = (ymax - ymin)*0.1
	xmin -= ww
	xmax += ww
	ymin -= hh
	ymax += hh
	self.contours = []
	self.layersPanel.loadLayersPanel(data, self.NotifyDataChange)
	self.canvas.loadData2(self.data, xmin, xmax, ymin, ymax)
	self.SetStatusText("Load Gerber file completed successfully", 0)
	self.origincombo.SetSelection(0)
	self.nativeLabel.SetLabelText("(File unit: %s, Dec. places: %0d)" % ("mm" if data.units == 0 else "in", data.fraction))
	def LoadEdgeFile(self, evt):
	if self.data is None:
	dlg = wx.MessageDialog(self, "You must load a Gerber file first", "Error", wx.OK | wx.ICON_ERROR)
	dlg.ShowModal()
	dlg.Destroy()
	return
	dlg = wx.FileDialog(self, "Open edge file", "", "",
	"Gerber Files (*.gml;*.gbl;*.gtl;*.gbr;*.cmp)|*.gml;*.gbl;*.gtl;*.gbr;*.cmp|All Files (*.*)|*",
	wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
	if dlg.ShowModal() == wx.ID_CANCEL:
	self.SetStatusText("Load edge file cancelled by user", 0)
	return
	filename = dlg.GetPath()
	dlg.Destroy()
	self.SetStatusText("Loading edge: " + filename + "...", 0)
	[data, edges] = load_file(filename)
	brdoutline = []
	brdseg = -1
	while len(edges) > 0:
	brdoutline.append([])
	brdseg += 1
	brdoutline[brdseg].extend(edges[0])
	edges.remove(edges[0])
	startpnt = brdoutline[brdseg][0]
	endpnt = brdoutline[brdseg][len(brdoutline[brdseg]) - 1]
	while (abs(startpnt[0] - endpnt[0]) > 10) | (abs(startpnt[1] - endpnt[1]) > 10):
	found = False
	for seg in edges:
	if abs(seg[0][0] - endpnt[0]) < 10:
	if abs(seg[0][1] - endpnt[1]) < 10:
	brdoutline[brdseg].extend(seg)
	edges.remove(seg)
	endpnt = brdoutline[brdseg][len(brdoutline[brdseg]) - 1]
	found = True
	break
	if abs(seg[len(seg) - 1][0] - endpnt[0]) < 10:
	if abs(seg[len(seg) - 1][1] - endpnt[1]) < 10:
	edges.remove(seg)
	seg = seg[::-1]
	brdoutline[brdseg].extend(seg)
	endpnt = brdoutline[brdseg][len(brdoutline[brdseg]) - 1]
	found = True
	break
	if not found:
	dlg = wx.MessageDialog(self, "Edge outline cannot contain any gaps.\n"
	"No changes were made.", "Load edge file failed",
	wx.OK | wx.ICON_ERROR)
	dlg.ShowModal()
	dlg.Destroy()
	self.SetStatusText("Load edge failed", 0)
	return
	xmin = 1E99
	xmax = -1E99
	ymin = 1E99
	ymax = -1E99
	if data.units == self.data.units:
	for poly in brdoutline:
	for (x, y) in poly:
	if x < xmin: xmin = x
	if x > xmax: xmax = x
	if y < ymin: ymin = y
	if y > ymax: ymax = y
	else:
	# finx bounds and convert units of data at same time
	conv = 25.4 if data.units == 1 else 1/25.4
	print " Unit conversion of edge file data"
	for poly in brdoutline:
	for pt in poly:
	x = pt[0] = int(pt[0] * conv)
	y = pt[1] = int(pt[1] * conv)
	if x < xmin: xmin = x
	if x > xmax: xmax = x
	if y < ymin: ymin = y
	if y > ymax: ymax = y
	# Check if PCB fits inside edge. We're lazy so we just use box bounds (should really use
	# polygon bounds checking).
	eps = 10
	if self.data.xmin2 + eps < xmin or self.data.xmax2 - eps > xmax or \
	self.data.ymin2 + eps < ymin or self.data.ymax2 - eps > ymax:
	print self.data.xmin, xmin
	print self.data.ymin, ymin
	print self.data.xmax, xmax
	print self.data.ymax, ymax
	dlg = wx.MessageDialog(self, "The loaded edge does not fully contain the PCB board.\n"
	"Do you still wish to proceed using this edge file?",
	"PCB board extends past edge boundary", wx.YES | wx.NO | wx.ICON_WARNING)
	ans = dlg.ShowModal()
	dlg.Destroy()
	if ans != wx.ID_YES:
	self.SetStatusText("Load edge file cancelled by user", 0)
	return
	self.data.xmin = xmin
	self.data.xmax = xmax
	self.data.ymin = ymin
	self.data.ymax = ymax
	# View bounds
	# Includes the origin
	if xmin > 0: xmin = 0
	if xmax < 0: xmax = 0
	if ymin > 0: ymin = 0
	if ymax < 0: ymax = 0
	# Add margin
	ww = (xmax - xmin)*0.1
	hh = (ymax - ymin)*0.1
	xmin -= ww
	xmax += ww
	ymin -= hh
	ymax += hh
	pcb_edges = brdoutline
	pcb_edges = pyclipper.CleanPolygons(pcb_edges)
	for poly in pcb_edges:
	poly.append(poly[0]) # close off polygons
	# Remove existing edge
	layers = list(self.data.layers)
	for gl in layers:
	if gl.type == GerberLayer.TYPE_PCBEDGE: self.data.layers.remove(gl)
	# Add edge data to existing data
	self.data.layers.insert(-1, GerberLayer(True, "PCB Edge", pcb_edges, True, False, "blue", GerberLayer.TYPE_PCBEDGE))
	self.pcb_edges = pcb_edges
	self.canvas.toolpaths = []
	self.canvas.loadData2(self.data, xmin, xmax, ymin, ymax)
	self.layersPanel.loadLayersPanel(self.data, self.NotifyDataChange)
	self.SetStatusText("Load edge file completed successfully", 0)
	def LoadDrillFile(self, evt=None):
	if self.data is None:
	dlg = wx.MessageDialog(self, "You must load a Gerber file first", "Error", wx.OK | wx.ICON_ERROR)
	dlg.ShowModal()
	dlg.Destroy()
	return
	dlg = wx.FileDialog(self, "Open edge file", "", "",
	"Drill files (*.drl;*.dbd;*.txt)|*.drl;*.dbd;*.txt|All Files (*.*)|*",
	wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
	if dlg.ShowModal() == wx.ID_CANCEL:
	self.SetStatusText("Load drill file cancelled by user", 0)
	return
	filename = dlg.GetPath()
	dlg.Destroy()
	self.SetStatusText("Loading drill: " + filename + "...", 0)
	[drillPts, units] = ExcellonReader.load_file(filename)
	fscale = 10**self.data.fraction
	if self.data.units != units:
	print "Conversion of drill file coords required"
	if units == 0:
	# mm -> in
	fscale *= 25.4
	else:
	# in -> mm
	fscale /= 25.4
	drillPts2 = []
	for (x, y, dia) in drillPts:
	drillPts2.append([int(x*fscale), int(y*fscale), int(dia*fscale)])
	self.canvas.drillPts = drillPts2
	print " Loaded ", len(drillPts), " drill points"
	self.SetStatusText("Load drill file completed successfully", 0)
	self.NotifyDataChange()
	def ClearDrillData(self, evt):
	self.canvas.drillPts = []
	self.NotifyDataChange()
	self.SetStatusText("Drill data removed", 0)
	def OnUpdateShowCutWidth(self, evt):
	self.canvas.toolpathlinewidth = float(self.tooldiainput.GetValue()) \
	if self.showcutwidthcheckbox.IsChecked() else 0
	self.NotifyDataChange()
	def addContour(self, evt=None):
	if self.data is None: return
	print "contouring boundary ..."
	self.contours = []
	N_contour = int(self.ncontourinput.GetValue())
	overlap = float(self.contourundercutinput.GetValue())
	if self.showcutwidthcheckbox.IsChecked(): self.canvas.toolpathlinewidth = float(self.tooldiainput.GetValue())
	toolpaths = self.canvas.toolpaths = []
	toolrad = float(self.tooldiainput.GetValue()) / 2.0 / self.canvas.mousescale
	self.contours = self.offset_poly(self.boundarys, toolrad)
	toolpaths.extend(self.contours)
	delrad = overlap * toolrad
	for n in range(1, N_contour):
	toolrad += delrad
	self.contours = self.offset_poly(self.boundarys, toolrad)
	toolpaths.extend(self.contours)
	toolpaths.extend(self.pcb_edges)
	for seg in toolpaths:
	if len(seg) > 0:
	seg.append(seg[0])
	self.contoolpaths = list(toolpaths) # cache to allow multiple raster
	self.canvas.updateToolpathData() # update toolpath cahce of wxGerberCanvas - this is to workaround a bug
	print " done"
	self.SetStatusText("Contour completed", 0)
	self.NotifyDataChange()
	def clearToolpath(self, evt=None):
	self.contours = []
	self.contoolpaths = []
	self.canvas.toolpaths = []
	self.NotifyDataChange()
	self.SetStatusText("Toolpath data removed", 0)
	def addToolpath(self, evt=None):
	# previously called raster operation
	if self.data is None: return
	print "rastering interior ..."
	tooldia = float(self.tooldiainput.GetValue()) / self.canvas.mousescale
	if self.showcutwidthcheckbox.IsChecked(): self.canvas.toolpathlinewidth = float(self.tooldiainput.GetValue())
	self.canvas.toolpaths = []
	if self.contours == []:
	edgepath = self.boundarys
	delta = tooldia / 2.0
	else:
	edgepath = self.contours
	self.canvas.toolpaths.extend(self.contoolpaths)
	delta = 0 # tooldia/4.0
	pcbedges = self.pcb_edges
	# pcbedges = []
	# for layer in self.pcb_edges:
	# tmp = []
	# for seg in layer:
	# tmp.append(seg[0] + xoff, seg[0] + yoff)
	rasterpath = self.raster_area(edgepath, pcbedges, delta, self.data.ymin, self.data.ymax, self.data.xmin, self.data.xmax)
	# toolpaths[0].extend(pyclipper.PolyTreeToPaths(rasterpath))
	self.canvas.toolpaths.extend(rasterpath)
	self.canvas.updateToolpathData() # update toolpath cahce of wxGerberCanvas - this is to workaround a bug
	print " done"
	self.SetStatusText("Raster completed", 0)
	self.NotifyDataChange()
	def raster_area(self, edgepath, pcbedges, delta, ymin1, ymax1, xmin1, xmax1):
	#
	# raster a 2D region
	#
	# find row-edge intersections
	#
	overlap = float(self.rasteroverlapinput.GetValue())
	tooldia = float(self.tooldiainput.GetValue()) / self.canvas.mousescale
	rastlines = []
	starty = ymin1
	endy = ymax1
	startx = round(xmax1, 2)
	endx = round(xmin1, 2)
	numrows = int(math.floor((endy - starty) / (tooldia * overlap)))
	crast = pyclipper.Pyclipper()
	edgepath = self.offset_poly(edgepath, delta)
	result = []
	for row in range(numrows + 1):
	rastlines.append([])
	ty = round(starty + row * (tooldia * overlap), 4)
	rastlines[row].append([startx, ty])
	rastlines[row].append([endx, ty])
	startx, endx = endx, startx
	tmp = []
	for i in range(numrows):
	tmp.append(rastlines[i][0][1])
	crast.AddPaths(pcbedges, pyclipper.PT_CLIP,True)
	crast.AddPaths(rastlines, pyclipper.PT_SUBJECT, False)
	rastlines = crast.Execute2(pyclipper.CT_INTERSECTION, pyclipper.PFT_EVENODD, pyclipper.PFT_EVENODD)
	crast.Clear()
	rastlines = pyclipper.PolyTreeToPaths(rastlines)
	##
	crast.AddPaths(edgepath, pyclipper.PT_CLIP, True)
	crast.AddPaths(rastlines, pyclipper.PT_SUBJECT, False)
	rastlines = crast.Execute2(pyclipper.CT_DIFFERENCE, pyclipper.PFT_POSITIVE, pyclipper.PFT_POSITIVE)
	crast.Clear()
	rastlines = pyclipper.PolyTreeToPaths(rastlines)
	# polyclip.sort(key=lambda x: (x[0][1],x[0][0]))
	# polyclip.sort(key=lambda x: x[0][1])
	# polyclip.sort(key=lambda x: x[0][0])
	rastltor = []
	rastrtol = []
	for segs in rastlines:
	if segs[0][0] < segs[1][0]:
	rastltor.append(segs)
	else:
	rastrtol.append(segs)
	rastltor.sort(key=lambda x: (x[0][1], x[0][0]))
	rastrtol.sort(key=lambda x: (x[0][1], -x[0][0]))
	result.extend(rastltor)
	result.extend(rastrtol)
	result.sort(key=lambda x: x[0][1])
	return result
	def offset_poly(self, path, toolrad):
	c_osp = pyclipper.PyclipperOffset()
	c_osp.AddPaths(path, pyclipper.JT_SQUARE, pyclipper.ET_CLOSEDPOLYGON)
	polyclip = c_osp.Execute(toolrad)
	polyclip = pyclipper.CleanPolygons(polyclip)
	c_osp.Clear()
	return polyclip
	def write_G(self):
	#
	# G code output
	#
	data = self.data
	scale = self.canvas.mousescale # NOTE: this takes units into account as well!
	feed = float(self.feedrateinput.GetValue())
	zup = self.zupinput.GetValue()
	zdown = self.zdowninput.GetValue()
	xoff = -data.originx * scale
	yoff = -data.originy * scale
	cool = self.coolantcheckbox.IsChecked()
	text = self.fileoutputinput.GetValue()
	file = open(text, 'w')
	# file.write("%\n")
	file.write("G20\n")
	file.write("T" + self.toolinput.GetValue() + "M06\n") # tool
	file.write("G90 G54\n") # absolute positioning with respect to set origin
	file.write("F%0.3f\n" % feed) # feed rate
	file.write("S" + self.spindlespeedinput.GetValue() + "\n") # spindle speed
	if cool: file.write("M08\n") # coolant on
	file.write("G0 Z" + zup + "\n") # move up before starting spindle
	file.write("M3\n") # spindle on clockwise
	nsegment = 0
	if self.canvas.toolpaths == []:
	path = self.boundarys
	else:
	path = self.canvas.toolpaths
	if zdown == " ":
	raise StandardError("This line has an error")
	# zdown = zoff + zmin + (layer-0.50)*dlayer
	else:
	zdown = float(self.zdowninput.GetValue())
	for segment in range(len(path)):
	nsegment += 1
	vertex = 0
	x = path[segment][vertex][0] * scale + xoff
	y = path[segment][vertex][1] * scale + yoff
	file.write("G0 X%0.4f " % x + "Y%0.4f " % y + "Z" + self.zupinput.GetValue() + "\n") # rapid motion
	file.write("G1 Z%0.4f " % zdown + "\n") # linear motion
	for vertex in range(1, len(path[segment])):
	x = path[segment][vertex][0] * scale + xoff
	y = path[segment][vertex][1] * scale + yoff
	file.write("G1 X%0.4f " % x + "Y%0.4f" % y + "\n")
	file.write("Z" + zup + "\n")
	# for layer in range((len(boundarys) - 1), -1, -1):
	# if (toolpaths[layer] == []):
	# path = boundarys[layer]
	# else:
	# path = toolpaths[layer]
	# if (szdown.get() == " "):
	# raise StandardError("This line has an error")
	# # zdown = zoff + zmin + (layer-0.50)*dlayer
	# else:
	# zdown = float(szdown.get())
	# for segment in range(len(path)):
	# nsegment += 1
	# vertex = 0
	# x = path[segment][vertex][0] * xyscale * (10 ** -gerber_data.fraction) + xoff
	# y = path[segment][vertex][1] * xyscale * (10 ** -gerber_data.fraction) + yoff
	# file.write("G0 X%0.4f " % x + "Y%0.4f " % y + "Z" + szup.get() + "\n") # rapid motion
	# file.write("G1 Z%0.4f " % zdown + "\n") # linear motion
	# for vertex in range(1, len(path[segment])):
	# x = path[segment][vertex][0] * xyscale * (10 ** -gerber_data.fraction) + xoff
	# y = path[segment][vertex][1] * xyscale * (10 ** -gerber_data.fraction) + yoff
	# file.write("G1 X%0.4f " % x + "Y%0.4f" % y + "\n")
	# file.write("Z" + szup.get() + "\n")
	file.write("G0 Z" + zup + "\n") # move up before stopping spindle
	file.write("M5\n") # spindle stop
	if cool: file.write("M09\n") # coolant off
	file.write("M30\n") # program end and reset
	# file.write("%\n")
	file.close()
	self.SetStatusText("Successfully written " + str(nsegment) + " G code toolpath segments to " + text, 0)
	def write_l(self):
	#
	# LaZoR Mk1 code output
	#
	data = self.data
	scale = self.canvas.mousescale # NOTE: this takes units into account as well!
	# dlayer = float(sthickness.get())/zscale
	feed = float(self.feedrateinput.GetValue())
	xoff = -data.originx * scale
	yoff = -data.originy * scale
	cool = self.coolantcheckbox.IsChecked()
	text = self.fileoutputinput.GetValue()
	file = open(text, 'w')
	# file.write("%\n")
	# file.write("O1234\n")
	# file.write("T"+stool.get()+"M06\n") # tool
	file.write("G90G54\n") # absolute positioning with respect to set origin
	# file.write("F%0.3f\n"%feed) # feed rate
	file.write("S" + str(float(self.spindlespeedinput.GetValue()) / 100) + "\n") # spindle speed
	# if (cool == TRUE): file.write("M08\n") # coolant on
	# file.write("G00Z"+szup.get()+"\n") # move up before starting spindle
	# file.write("M03\n") # spindle on clockwise
	nsegment = 0
	for layer in range((len(self.boundarys) - 1), -1, -1):
	# FIXME: toolpath will not have same number of layers as boundarys
	if self.canvas.toolpaths[layer] == []:
	path = self.boundarys[layer]
	else:
	path = self.canvas.toolpaths[layer]
	## if (szdown.get() == " "):
	## zdown = zoff + zmin + (layer-0.50)*dlayer
	## else:
	## zdown = float(szdown.get())
	for segment in range(len(path)):
	## if (len(path[segment])==0):
	## continue
	nsegment += 1
	vertex = 0
	x = path[segment][vertex][0] * scale + xoff
	y = path[segment][vertex][1] * scale + yoff
	file.write("G00X%0.4f" % x + "Y%0.4f" % y + "\n") # rapid motion
	# file.write("G01Z%0.4f"%zdown+"\n") # linear motion
	file.write("M03\n")
	for vertex in range(1, len(path[segment])):
	x = path[segment][vertex][0] * scale + xoff
	y = path[segment][vertex][1] * scale + yoff
	file.write("G01X%0.4f" % x + "Y%0.4f" % y + "F%0.3f\n" % feed + "\n")
	# file.write("Z"+szup.get()+"\n")
	file.write("M05\n")
	# file.write("G00Z"+szup.get()+"\n") # move up before stopping spindle
	file.write("M05\n") # spindle stop
	if cool: file.write("M09\n") # coolant off
	file.write("M30\n") # program end and reset
	# file.write("%\n")
	file.close()
	self.SetStatusText("Successfully written " + str(nsegment) + " LaZoR code toolpath segments to " + text, 0)
	def NotifyDataChange(self):
	self.canvas.redraw()
	self.canvas.Refresh()
	def setComp(self, comp, val):
	if val is None:
	comp.SetValue("")
	comp.Disable()
	else:
	comp.Enable()
	comp.SetValue(val)
	class LayersPanel(wx.lib.scrolledpanel.ScrolledPanel):
	""" Gerber layer's editing panel """
	def __init__(self, parent):
	super(LayersPanel, self).__init__(parent, size=(300, 0))
	self.g = None
	self.data = None
	""" Gerber data :type data: GerberData """
	self.notify = None
	""" Called when data has been modified """
	self.Col = -1
	def loadLayersPanel(self, data=None, change_notifier=None):
	"""
	:type data: GerberData
	"""
	if data is not None: self.data = data
	if change_notifier is not None: self.notify = change_notifier
	self.Freeze()
	if self.g is not None: self.DestroyChildren()
	g = wx.grid.Grid(self)
	self.g = g
	g.CreateGrid(0 if data is None else len(data.layers), 5)
	g.HideRowLabels()
	g.DisableDragRowSize()
	g.SetColLabelValue(0, "Name")
	g.SetColLabelValue(1, " ")
	g.SetColLabelValue(2, "Visible")
	g.SetColLabelValue(3, "Filled")
	g.SetColLabelValue(4, "Colour")
	# get the cell attribute for the top left row
	# editor = layersPanel.GetCellEditor(0, 0)
	attr = wx.grid.GridCellAttr()
	attr.SetReadOnly(True)
	g.SetColAttr(0, attr)
	g.SetColAttr(1, attr)
	g.SetColAttr(4, attr)
	attr = wx.grid.GridCellAttr()
	attr.SetEditor(wx.grid.GridCellBoolEditor())
	attr.SetRenderer(wx.grid.GridCellBoolRenderer())
	g.SetColAttr(2, attr)
	g.SetColAttr(3, attr)
	g.SetColSize(0, 125)
	g.SetColSize(1, 25)
	g.SetColSize(2, 50)
	g.SetColSize(3, 50)
	g.SetColSize(4, 50)
	g.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.onMouse)
	g.Bind(wx.grid.EVT_GRID_SELECT_CELL, self.onCellSelected)
	g.Bind(wx.grid.EVT_GRID_EDITOR_CREATED, self.onEditorCreated)
	if data is not None:
	r = 0
	for gl in data.layers:
	g.SetCellValue(r, 0, gl.name)
	g.SetCellValue(r, 1, "D" if gl.isDark else "C")
	g.SetCellValue(r, 2, '1' if gl.visible else '')
	g.SetCellValue(r, 3, '1' if gl.filled else '')
	g.SetCellBackgroundColour(r, 4, gl.color)
	if len(gl.points) == 0: g.SetCellTextColour(r, 0, "#808080") # grey out empty layers
	r += 1
	# r = 0 # test values
	# self.SetCellValue(r, 0, "Test name")
	# self.SetCellValue(r, 1, "D")
	# self.SetCellValue(r, 2, '1')
	# self.SetCellValue(r, 3, '')
	# self.SetCellValue(r, 5, "green")
	sizedToFill(g)
	self.SetupScrolling(False, True)
	self.Thaw()
	# Methods below used to hack wx.grid to allow one click toggling of checkboxed
	# Also modified to activate colour picker
	def onMouse(self,evt):
	if evt.Col == 2 or evt.Col == 3:
	self.Col = evt.Col
	wx.CallLater(100, self.toggleCheckBox)
	elif evt.Col == 4:
	gl = self.data.layers[evt.Row]
	# Change colour
	cdata = wx.ColourData()
	cdata.SetColour(gl.color)
	cdata.ChooseFull = True
	dlg = wx.ColourDialog(self, cdata)
	if dlg.ShowModal() == wx.ID_OK:
	newcol = dlg.GetColourData().Colour.GetAsString(wx.C2S_HTML_SYNTAX)
	gl.color = newcol
	# update ui
	self.g.SetCellBackgroundColour(evt.Row, 4, gl.color)
	print gl.color, evt.Row
	self.notify()
	self.g.Refresh()
	dlg.Destroy()
	evt.Skip()
	def toggleCheckBox(self):
	self.cb.SetValue(not self.cb.Value)
	self.afterCheckBox(self.cb.Value)
	def onCellSelected(self, evt):
	if evt.Col == 2 or evt.Col == 3:
	self.Col = evt.Col
	wx.CallAfter(self.g.EnableCellEditControl)
	evt.Skip()
	def onEditorCreated(self, evt):
	if evt.Col == 2 or evt.Col == 3:
	self.cb = evt.Control
	self.Col = evt.Col
	self.cb.WindowStyle |= wx.WANTS_CHARS
	self.cb.Bind(wx.EVT_KEY_DOWN, self.onKeyDown)
	self.cb.Bind(wx.EVT_CHECKBOX, self.onCheckBox)
	evt.Skip()
	def onKeyDown(self, evt):
	if evt.KeyCode == wx.WXK_UP:
	if self.g.GridCursorRow > 0:
	self.g.DisableCellEditControl()
	self.g.MoveCursorUp(False)
	elif evt.KeyCode == wx.WXK_DOWN:
	if self.g.GridCursorRow < (self.g.NumberRows-1):
	self.g.DisableCellEditControl()
	self.g.MoveCursorDown(False)
	elif evt.KeyCode == wx.WXK_LEFT:
	if self.g.GridCursorCol > 0:
	self.g.DisableCellEditControl()
	self.g.MoveCursorLeft(False)
	elif evt.KeyCode == wx.WXK_RIGHT:
	if self.g.GridCursorCol < (self.g.NumberCols-1):
	self.g.DisableCellEditControl()
	self.g.MoveCursorRight(False)
	else:
	evt.Skip()
	def onCheckBox(self, evt):
	self.afterCheckBox(evt.IsChecked())
	evt.Skip()
	def afterCheckBox(self, isChecked):
	if self.Col == 2:
	self.data.layers[self.g.GridCursorRow].visible = isChecked
	else:
	self.data.layers[self.g.GridCursorRow].filled = isChecked
	self.notify()
	#=======================================================
	app = wx.App()
	frame = LazorAppFrame()
	frame.Show()
	app.MainLoop()