BCN3D-Cura-SourceCode

__copyright__ = "Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License"

import wx
import os
import webbrowser
import sys
#import mexPanel
#import idexPanel
import ConfigParser as configparser

from Cura.gui import configBase
from Cura.gui import expertConfig
from Cura.gui import alterationPanel
from Cura.gui import pluginPanel
from Cura.gui import preferencesDialog
from Cura.gui import configWizard
from Cura.gui import firmwareInstall
from Cura.gui import simpleMode
from Cura.gui import sceneView
from Cura.gui import aboutWindow
from Cura.gui.util import dropTarget
#from Cura.gui.tools import batchRun
from Cura.gui.tools import pidDebugger
from Cura.gui.tools import minecraftImport
from Cura.util import profile
from Cura.util import version
from Cura.gui import configFirmware
from Cura.util import machineCom
import platform
from Cura.util import meshLoader

try:
    #MacOS release currently lacks some wx components, like the Publisher.
    from wx.lib.pubsub import Publisher
except:
    Publisher = None

class mainWindow(wx.Frame):
    def __init__(self):
        super(mainWindow, self).__init__(None, title='Cura-BCN3D-' + version.getVersion() + '-beta2')

        wx.EVT_CLOSE(self, self.OnClose)

        # allow dropping any file, restrict later
        self.SetDropTarget(dropTarget.FileDropTarget(self.OnDropFiles))

        # TODO: wxWidgets 2.9.4 has a bug when NSView does not register for dragged types when wx drop target is set. It was fixed in 2.9.5
        if sys.platform.startswith('darwin'):
            try:
                import objc
                nswindow = objc.objc_object(c_void_p=self.MacGetTopLevelWindowRef())
                view = nswindow.contentView()
                view.registerForDraggedTypes_([u'NSFilenamesPboardType'])
            except:
                pass

        self.normalModeOnlyItems = []

        mruFile = os.path.join(profile.getBasePath(), 'mru_filelist.ini')
        self.config = wx.FileConfig(appName="Cura",
                        localFilename=mruFile,
                        style=wx.CONFIG_USE_LOCAL_FILE)

        self.ID_MRU_MODEL1, self.ID_MRU_MODEL2, self.ID_MRU_MODEL3, self.ID_MRU_MODEL4, self.ID_MRU_MODEL5, self.ID_MRU_MODEL6, self.ID_MRU_MODEL7, self.ID_MRU_MODEL8, self.ID_MRU_MODEL9, self.ID_MRU_MODEL10 = [wx.NewId() for line in xrange(10)]
        self.modelFileHistory = wx.FileHistory(10, self.ID_MRU_MODEL1)
        self.config.SetPath("/ModelMRU")
        self.modelFileHistory.Load(self.config)

        self.ID_MRU_PROFILE1, self.ID_MRU_PROFILE2, self.ID_MRU_PROFILE3, self.ID_MRU_PROFILE4, self.ID_MRU_PROFILE5, self.ID_MRU_PROFILE6, self.ID_MRU_PROFILE7, self.ID_MRU_PROFILE8, self.ID_MRU_PROFILE9, self.ID_MRU_PROFILE10 = [wx.NewId() for line in xrange(10)]
        self.profileFileHistory = wx.FileHistory(10, self.ID_MRU_PROFILE1)
        self.config.SetPath("/ProfileMRU")
        self.profileFileHistory.Load(self.config)

        #Now we create the different menu options, the first one is the options displayed by the 'File' button
        self.menubar = wx.MenuBar()
        self.fileMenu = wx.Menu()
        i = self.fileMenu.Append(-1, _("Load model file...\tCTRL+L"))
        self.Bind(wx.EVT_MENU, lambda e: self.scene.showLoadModel(), i)
        i = self.fileMenu.Append(-1, _("Load Draudi file...\tCTRL+D"))
        self.Bind(wx.EVT_MENU, self.OnLoadDraudiModel, i)
        i = self.fileMenu.Append(-1, _("Save model...\tCTRL+S"))
        self.Bind(wx.EVT_MENU, lambda e: self.scene.showSaveModel(), i)
        i = self.fileMenu.Append(-1, _("Reload platform\tF5"))
        self.Bind(wx.EVT_MENU, lambda e: self.scene.reloadScene(e), i)
        i = self.fileMenu.Append(-1, _("Clear platform\tCTRL+Q"))
        self.Bind(wx.EVT_MENU, lambda e: self.scene.OnDeleteAll(e), i)

        self.fileMenu.AppendSeparator()
        i = self.fileMenu.Append(-1, _("Print...\tCTRL+P"))
        self.Bind(wx.EVT_MENU, lambda e: self.scene.OnPrintButton(1), i)
        i = self.fileMenu.Append(-1, _("Save GCode...\tCTRL+G"))
        self.Bind(wx.EVT_MENU, lambda e: self.scene.showSaveGCode(), i)
        i = self.fileMenu.Append(-1, _("Show slice engine log..."))
        self.Bind(wx.EVT_MENU, lambda e: self.scene._showEngineLog(), i)

        self.fileMenu.AppendSeparator()
        i = self.fileMenu.Append(-1, _("Open Profile...\tCTRL+C"))
        self.normalModeOnlyItems.append(i)
        self.Bind(wx.EVT_MENU, lambda e: self.scene.OnLoadConfigurations(), i)
        i = self.fileMenu.Append(-1, _("Save Profile..."))
        self.normalModeOnlyItems.append(i)
        self.Bind(wx.EVT_MENU, self.OnSaveProfile, i)
        if version.isDevVersion():
            i = self.fileMenu.Append(-1, "Save difference from default...")
            self.normalModeOnlyItems.append(i)
            self.Bind(wx.EVT_MENU, self.OnSaveDifferences, i)
        i = self.fileMenu.Append(-1, _("Load Profile from GCode..."))
        self.normalModeOnlyItems.append(i)
        self.Bind(wx.EVT_MENU, self.OnLoadProfileFromGcode, i)

        self.fileMenu.AppendSeparator()
        i = self.fileMenu.Append(-1, _("Preferences...\tCTRL+,"))
        self.Bind(wx.EVT_MENU, self.OnPreferences, i)
        i = self.fileMenu.Append(-1, _("Machine settings..."))
        self.Bind(wx.EVT_MENU, self.OnMachineSettings, i)
        self.fileMenu.AppendSeparator()

        # Model MRU list
        modelHistoryMenu = wx.Menu()
        self.fileMenu.AppendMenu(wx.NewId(), '&' + _("Recent Model Files"), modelHistoryMenu)
        self.modelFileHistory.UseMenu(modelHistoryMenu)
        self.modelFileHistory.AddFilesToMenu()
        self.Bind(wx.EVT_MENU_RANGE, self.OnModelMRU, id=self.ID_MRU_MODEL1, id2=self.ID_MRU_MODEL10)

        # Profle MRU list
        profileHistoryMenu = wx.Menu()
        self.fileMenu.AppendMenu(wx.NewId(), _("Recent Profile Files"), profileHistoryMenu)
        self.profileFileHistory.UseMenu(profileHistoryMenu)
        self.profileFileHistory.AddFilesToMenu()
        self.Bind(wx.EVT_MENU_RANGE, self.OnProfileMRU, id=self.ID_MRU_PROFILE1, id2=self.ID_MRU_PROFILE10)

        self.fileMenu.AppendSeparator()
        i = self.fileMenu.Append(wx.ID_EXIT, _("Quit"))
        self.Bind(wx.EVT_MENU, self.OnQuit, i)
        #Here we set the name of the menubar, which in this case is 'File'
        self.menubar.Append(self.fileMenu, '&' + _("File"))


        #The next menu option is 'Tools'
        toolsMenu = wx.Menu()
        #At BCN3D we do not recommend printing one at a time and we have set a message to come up
        #in case a user does choose that option.
        self.allAtOnceItem = toolsMenu.Append(-1, _("Print all at once"), kind=wx.ITEM_RADIO)
        self.Bind(wx.EVT_MENU, self.onOneAtATimeSwitch, self.allAtOnceItem)
        self.oneAtATime = toolsMenu.Append(-1, _("Print one at a time"), kind=wx.ITEM_RADIO)
        self.Bind(wx.EVT_MENU, self.onOneAtATimeSwitch, self.oneAtATime)
        if profile.getPreference('oneAtATime') == 'True':
            self.oneAtATime.Check(True)
        else:
            self.allAtOnceItem.Check(True)

        #We name this menu option
        self.menubar.Append(toolsMenu, _("Tools"))

        #Machine menu for machine configuration/tooling
        self.machineMenu = wx.Menu()
        self.updateMachineMenu()

        self.menubar.Append(self.machineMenu, _("Machine"))

        #we switch between panels
        expertMenu = wx.Menu()
        i = expertMenu.Append(-1, _("Switch to quickprint..."), kind=wx.ITEM_RADIO)
        self.switchToQuickprintMenuItem = i
        self.Bind(wx.EVT_MENU, self.OnSimpleSwitch, i)

        i = expertMenu.Append(-1, _("Switch to full settings..."), kind=wx.ITEM_RADIO)
        self.switchToNormalMenuItem = i
        self.Bind(wx.EVT_MENU, self.OnNormalSwitch, i)
        expertMenu.AppendSeparator()

        #Open a series of settings that you are not normally able to see
        i = expertMenu.Append(-1, _("Open expert settings...\tCTRL+E"))
        self.normalModeOnlyItems.append(i)
        self.Bind(wx.EVT_MENU, self.OnExpertOpen, i)
        expertMenu.AppendSeparator()
        self.bedLevelWizardMenuItem = expertMenu.Append(-1, _("Run bed leveling wizard..."))
        self.Bind(wx.EVT_MENU, self.OnBedLevelWizard, self.bedLevelWizardMenuItem)
        self.headOffsetWizardMenuItem = expertMenu.Append(-1, _("Run head offset wizard..."))
        self.Bind(wx.EVT_MENU, self.OnHeadOffsetWizard, self.headOffsetWizardMenuItem)

        #give the menu bar a name, in this case 'Expert'
        self.menubar.Append(expertMenu, _("Expert"))

        helpMenu = wx.Menu()
        i = helpMenu.Append(-1, _("Online documentation..."))
        self.Bind(wx.EVT_MENU, lambda e: webbrowser.open('http://www.bcn3dtechnologies.com/es/forum'), i)
        if sys.platform.startswith('win'):
            i = helpMenu.Append(-1, _("Report a problem..."))
            self.Bind(wx.EVT_MENU, lambda e: webbrowser.open('https://github.com/BCN3D/BCN3D-Cura-Windows/issues'), i)
        elif sys.platform.startswith('darwin'):
            i = helpMenu.Append(-1, _("Report a problem..."))
            self.Bind(wx.EVT_MENU, lambda e: webbrowser.open('https://github.com/BCN3D/BCN3D-Cura-Mac/issues'), i)
        i = helpMenu.Append(-1, _("Check for update..."))
        self.Bind(wx.EVT_MENU, self.OnCheckForUpdate, i)
        i = helpMenu.Append(-1, _("About Cura..."))
        self.Bind(wx.EVT_MENU, self.OnAbout, i)
        self.menubar.Append(helpMenu, _("Help"))
        self.SetMenuBar(self.menubar)

        self.splitter = wx.SplitterWindow(self, style = wx.SP_3D | wx.SP_LIVE_UPDATE)
        self.leftPane = wx.Panel(self.splitter, style=wx.BORDER_NONE)
        self.rightPane = wx.Panel(self.splitter, style=wx.BORDER_NONE)
        self.splitter.Bind(wx.EVT_SPLITTER_DCLICK, lambda evt: evt.Veto())

        #Preview window
        self.scene = sceneView.SceneView(self.rightPane)

        ##Gui components##
        #We want two different simple modes, one for BCN3D users and the default cura one for other machines
        #Currently working on this, will be available soon
        #machine_type = profile.getMachineSetting('machine_type')
        #if machine_type == 'BCN3DSigma':
           # self.simpleSettingsPanel = simpleModeSigma(self.leftPane, self.scene.sceneUpdated)
        #else:
        #call to the different panels
        self.simpleSettingsPanel = simpleMode.simpleModePanel(self.leftPane, self.scene.sceneUpdated)
        self.normalSettingsPanel = normalSettingsPanel(self.leftPane, self.scene.sceneUpdated)

        #Simple panel will be fix while you can change the size for advanced panel
        self.leftSizer = wx.BoxSizer(wx.VERTICAL)
        self.leftSizer.Add(self.simpleSettingsPanel, 1)
        self.leftSizer.Add(self.normalSettingsPanel, 1, wx.EXPAND)
        self.leftPane.SetSizer(self.leftSizer)

        #Main sizer, to position the preview window, buttons and tab control
        sizer = wx.BoxSizer()
        self.rightPane.SetSizer(sizer)
        sizer.Add(self.scene, 1, flag=wx.EXPAND)

        # Main window sizer
        sizer = wx.BoxSizer(wx.VERTICAL)
        self.SetSizer(sizer)
        sizer.Add(self.splitter, 1, wx.EXPAND)
        sizer.Layout()
        self.sizer = sizer

        self.updateProfileToAllControls()

        self.SetBackgroundColour(self.normalSettingsPanel.GetBackgroundColour())

        self.simpleSettingsPanel.Show(False)
        self.normalSettingsPanel.Show(False)

        # Set default window size & position
        self.SetSize((wx.Display().GetClientArea().GetWidth()/2,wx.Display().GetClientArea().GetHeight()/2))
        self.Centre()

        #Timer set; used to check if profile is on the clipboard
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.onTimer)
        #self.timer.Start(1000)
        self.lastTriedClipboard = profile.getProfileString()

        # Restore the window position, size & state from the preferences file
        try:
            if profile.getPreference('window_maximized') == 'True':
                self.Maximize(True)
            else:
                posx = int(profile.getPreference('window_pos_x'))
                posy = int(profile.getPreference('window_pos_y'))
                width = int(profile.getPreference('window_width'))
                height = int(profile.getPreference('window_height'))
                if posx > 0 or posy > 0:
                    self.SetPosition((posx,posy))
                if width > 0 and height > 0:
                    self.SetSize((width,height))

            self.normalSashPos = int(profile.getPreference('window_normal_sash'))
        except:
            self.normalSashPos = 0
            self.Maximize(True)
        if self.normalSashPos < self.normalSettingsPanel.printPanel.GetBestSize()[0] + 5:
            self.normalSashPos = self.normalSettingsPanel.printPanel.GetBestSize()[0] + 5

        self.splitter.SplitVertically(self.leftPane, self.rightPane, self.normalSashPos)

        if wx.Display.GetFromPoint(self.GetPosition()) < 0:
            self.Centre()
        if wx.Display.GetFromPoint((self.GetPositionTuple()[0] + self.GetSizeTuple()[1], self.GetPositionTuple()[1] + self.GetSizeTuple()[1])) < 0:
            self.Centre()
        if wx.Display.GetFromPoint(self.GetPosition()) < 0:
            self.SetSize((800,600))
            self.Centre()

        self.updateSliceMode()
        self.scene.SetFocus()
        self.dialogframe = None
        if Publisher is not None:
            Publisher().subscribe(self.onPluginUpdate, "pluginupdate")

        pluginCount = self.normalSettingsPanel.pluginPanel.GetActivePluginCount()
        if pluginCount == 1:
            self.scene.notification.message("Warning: 1 plugin from the previous session is still active.")

        if pluginCount > 1:
            self.scene.notification.message("Warning: %i plugins from the previous session are still active." % pluginCount)

    def onPluginUpdate(self,msg): #receives commands from the plugin thread
        cmd = str(msg.data).split(";")
        if cmd[0] == "OpenPluginProgressWindow":
            if len(cmd)==1: #no titel received
                cmd.append("Plugin")
            if len(cmd)<3: #no message text received
                cmd.append("Plugin is executed...")
            dialogwidth = 300
            dialogheight = 80
            self.dialogframe = wx.Frame(self, -1, cmd[1],pos = ((wx.SystemSettings.GetMetric(wx.SYS_SCREEN_X)-dialogwidth)/2,(wx.SystemSettings.GetMetric(wx.SYS_SCREEN_Y)-dialogheight)/2), size=(dialogwidth,dialogheight), style = wx.STAY_ON_TOP)
            self.dialogpanel = wx.Panel(self.dialogframe, -1, pos = (0,0), size = (dialogwidth,dialogheight))
            self.dlgtext = wx.StaticText(self.dialogpanel, label = cmd[2], pos = (10,10), size = (280,40))
            self.dlgbar = wx.Gauge(self.dialogpanel,-1, 100, pos = (10,50), size = (280,20), style = wx.GA_HORIZONTAL)
            self.dialogframe.Show()

        elif cmd[0] == "Progress":
            number = int(cmd[1])
            if number <= 100 and self.dialogframe is not None:
                self.dlgbar.SetValue(number)
            else:
                self.dlgbar.SetValue(100)
        elif cmd[0] == "ClosePluginProgressWindow":
            self.dialogframe.Destroy()
            self.dialogframe=None
        else: #assume first token to be the name and second token the percentage
            if len(cmd)>=2:
                number = int(cmd[1])
            else:
                number = 100
            # direct output to Cura progress bar
            self.scene.printButton.setProgressBar(float(number)/100.)
            self.scene.printButton.setBottomText('%s' % (cmd[0]))
            self.scene.QueueRefresh()

    def onTimer(self, e):
        #Check if there is something in the clipboard
        profileString = ""
        try:
            if not wx.TheClipboard.IsOpened():
                if not wx.TheClipboard.Open():
                    return
                do = wx.TextDataObject()
                if wx.TheClipboard.GetData(do):
                    profileString = do.GetText()
                wx.TheClipboard.Close()

                startTag = "CURA_PROFILE_STRING:"
                if startTag in profileString:
                    #print "Found correct syntax on clipboard"
                    profileString = profileString.replace("\n","").strip()
                    profileString = profileString[profileString.find(startTag)+len(startTag):]
                    if profileString != self.lastTriedClipboard:
                        print profileString
                        self.lastTriedClipboard = profileString
                        profile.setProfileFromString(profileString)
                        self.scene.notification.message("Loaded new profile from clipboard.")
                        self.updateProfileToAllControls()
        except:
            print "Unable to read from clipboard"


    def updateSliceMode(self):
        isSimple = profile.getPreference('startMode') == 'Simple'

        self.normalSettingsPanel.Show(not isSimple)
        self.simpleSettingsPanel.Show(isSimple)
        self.leftPane.Layout()

        for i in self.normalModeOnlyItems:
            i.Enable(not isSimple)
        if isSimple:
            self.switchToQuickprintMenuItem.Check()
        else:
            self.switchToNormalMenuItem.Check()

        # Set splitter sash position & size
        if isSimple:
            # Save normal mode sash
            self.normalSashPos = self.splitter.GetSashPosition()

            # Change location of sash to width of quick mode pane
            (width, height) = self.simpleSettingsPanel.GetSizer().GetSize()
            self.splitter.SetSashPosition(width, True)

            # Disable sash
            self.splitter.SetSashSize(0)
        else:
            self.splitter.SetSashPosition(self.normalSashPos, True)
            # Enabled sash
            self.splitter.SetSashSize(4)
        if profile.getMachineSetting('machine_type').startswith('BCN3DSigma'):
            self.bedLevelWizardMenuItem.Enable(False)
            self.headOffsetWizardMenuItem.Enable(False)
        if int(profile.getMachineSetting('extruder_amount')) < 2:
            self.headOffsetWizardMenuItem.Enable(False)
        self.scene.updateProfileToControls()
        self.scene._scene.pushFree()

    def onOneAtATimeSwitch(self, e):
        profile.putPreference('oneAtATime', self.oneAtATime.IsChecked())
        if self.oneAtATime.IsChecked() and profile.getMachineSetting('machine_type').startswith('BCN3D'):
            wx.MessageBox(_('At BCN3D we do not recommend printing with the "One at a time" option. Proceed with care.'), _('One at a time warning'), wx.OK | wx.ICON_WARNING)
        if self.oneAtATime.IsChecked() and profile.getMachineSettingFloat('extruder_head_size_height') < 1:
            wx.MessageBox(_('For "One at a time" printing, you need to have entered the correct head size and gantry height in the machine settings'), _('One at a time warning'), wx.OK | wx.ICON_WARNING)
        self.scene.updateProfileToControls()
        self.scene._scene.pushFree()
        self.scene.sceneUpdated()

    def OnPreferences(self, e):
        prefDialog = preferencesDialog.preferencesDialog(self)
        prefDialog.Centre()
        prefDialog.Show()
        prefDialog.Raise()
        wx.CallAfter(prefDialog.Show)

    def OnMachineSettings(self, e):
        prefDialog = preferencesDialog.machineSettingsDialog(self)
        prefDialog.Centre()
        prefDialog.Show()
        prefDialog.Raise()

    def OnDropFiles(self, files):
        self.scene.loadFiles(files)

    def OnModelMRU(self, e):
        fileNum = e.GetId() - self.ID_MRU_MODEL1
        path = self.modelFileHistory.GetHistoryFile(fileNum)
        # Update Model MRU
        self.modelFileHistory.AddFileToHistory(path)  # move up the list
        self.config.SetPath("/ModelMRU")
        self.modelFileHistory.Save(self.config)
        self.config.Flush()
        # Load Model
        profile.putPreference('lastFile', path)
        filelist = [ path ]
        self.scene.loadFiles(filelist)

    def addToModelMRU(self, file):
        self.modelFileHistory.AddFileToHistory(file)
        self.config.SetPath("/ModelMRU")
        self.modelFileHistory.Save(self.config)
        self.config.Flush()

    def OnProfileMRU(self, e):
        fileNum = e.GetId() - self.ID_MRU_PROFILE1
        path = self.profileFileHistory.GetHistoryFile(fileNum)
        # Update Profile MRU
        self.profileFileHistory.AddFileToHistory(path)  # move up the list
        self.config.SetPath("/ProfileMRU")
        self.profileFileHistory.Save(self.config)
        self.config.Flush()
        # Load Profile
        profile.loadProfile(path)
        self.updateProfileToAllControls()

    def addToProfileMRU(self, file):
        self.profileFileHistory.AddFileToHistory(file)
        self.config.SetPath("/ProfileMRU")
        self.profileFileHistory.Save(self.config)
        self.config.Flush()

    def updateProfileToAllControls(self):
        self.scene.updateProfileToControls()
        self.normalSettingsPanel.updateProfileToControls()
        self.simpleSettingsPanel.updateProfileToControls()

    def reloadSettingPanels(self):
        machine_type = profile.getMachineSetting('machine_type')
        self.leftSizer.Detach(self.simpleSettingsPanel)
        self.leftSizer.Detach(self.normalSettingsPanel)
        self.simpleSettingsPanel.Destroy()
        self.normalSettingsPanel.Destroy()
        #if machine_type == 'BCN3DSigma':
            #self.simpleSettingsPanel = simpleModeSigma(self.leftPane, self.scene.sceneUpdated)
        #else:
        self.simpleSettingsPanel = simpleMode.simpleModePanel(self.leftPane, self.scene.sceneUpdated)
        self.normalSettingsPanel = normalSettingsPanel(self.leftPane, lambda : self.scene.sceneUpdated())
        self.leftSizer.Add(self.simpleSettingsPanel, 1)
        self.leftSizer.Add(self.normalSettingsPanel, 1, wx.EXPAND)
        self.updateSliceMode()
        self.updateProfileToAllControls()

    def updateMachineMenu(self):
        #Remove all items so we can rebuild the menu. Inserting items seems to cause crashes, so this is the safest way.
        for item in self.machineMenu.GetMenuItems():
            self.machineMenu.RemoveItem(item)

        #Add a menu item for each machine configuration.
        for n in xrange(0, profile.getMachineCount()):
            i = self.machineMenu.Append(n + 0x1000, profile.getMachineSetting('machine_name', n).title(), kind=wx.ITEM_RADIO)
            if n == int(profile.getPreferenceFloat('active_machine')):
                i.Check(True)
            self.Bind(wx.EVT_MENU, lambda e: self.OnSelectMachine(e.GetId() - 0x1000), i)

        self.machineMenu.AppendSeparator()
        i = self.machineMenu.Append(-1, _("Add new machine..."))
        self.Bind(wx.EVT_MENU, self.OnAddNewMachine, i)
        i = self.machineMenu.Append(-1, _("Machine settings..."))
        self.Bind(wx.EVT_MENU, self.OnMachineSettings, i)

        #Add tools for machines.
        self.machineMenu.AppendSeparator()

        self.updateHardwareFirmwareInstallMenu = self.machineMenu.Append(-1, _("Check for firmware updates..."))
        self.Bind(wx.EVT_MENU, self.OnUpdateHardwareFirmware, self.updateHardwareFirmwareInstallMenu)
 
        i = self.machineMenu.Append(-1, _("Install custom firmware..."))
        self.Bind(wx.EVT_MENU, self.OnCustomFirmware, i)

    def OnLoadDraudiModel(self, e):

        if sys.platform.startswith('win'):
            dir = r"C:\\Program Files (x86)\\Cura-BCN3D-%s-beta2\\resources\\draudi_stl" % version.getVersion()

            dlg = wx.FileDialog(self, _("Load Draudi File"), dir, style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST | wx.FD_MULTIPLE)
            dlg.SetWildcard("stl files (*.stl)|*.STL")

            if dlg.ShowModal() != wx.ID_OK:
                dlg.Destroy()
                return
            filenames = dlg.GetPaths()
            dlg.Destroy()
            if len(filenames) < 1:
                return False
            self.scene.loadFiles(filenames)

            # If we a running on mac os
        elif sys.platform.startswith('darwin'):
            dir = '/Applications/Cura/Cura-BCN3D.app/Contents/Resources/draudi_stl'

            dlg = wx.FileDialog(self, _("Load Draudi File"), dir, style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST | wx.FD_MULTIPLE)
            dlg.SetWildcard("stl files (*.stl)|*.STL")

            if dlg.ShowModal() != wx.ID_OK:
                dlg.Destroy()
                return
            filenames = dlg.GetPaths()
            dlg.Destroy()
            if len(filenames) < 1:
                return False
            self.scene.loadFiles(filenames)

    def OnLoadProfile(self):

        if sys.platform.startswith('win'):
            dir = r"C:\\Program Files (x86)\\Cura-BCN3D-%s-beta2\\resources\\configurations" % version.getVersion()
            #os.chdir(dir)
            dlg = wx.FileDialog(self, _("Select profile file to load"), dir, style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
            dlg.SetWildcard("ini files (*.ini)|*.ini")

            if dlg.ShowModal() == wx.ID_OK:
                profileFile = dlg.GetPath()
                profile.loadProfile(profileFile)
                self.updateProfileToAllControls()

                # Update the Profile MRU
                self.addToProfileMRU(profileFile)
            dlg.Destroy()
        if sys.platform.startswith('darwin'):
            dir = '/Applications/Cura/Cura-BCN3D.app/Contents/Resources/configurations'
            os.chdir(dir)
            dlg = wx.FileDialog(self, _("Select profile file to load"), dir, style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
            dlg.SetWildcard("ini files (*.ini)|*.ini")

            if dlg.ShowModal() == wx.ID_OK:
                profileFile = dlg.GetPath()
                profile.loadProfile(profileFile)
                self.updateProfileToAllControls()

                # Update the Profile MRU
                self.addToProfileMRU(profileFile)
            dlg.Destroy()

    def OnLoadProfileFromGcode(self, e):
        dlg=wx.FileDialog(self, _("Select gcode file to load profile from"), os.path.split(profile.getPreference('lastFile'))[0], style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST)
        dlg.SetWildcard("gcode files (*%s)|*%s;*%s" % (profile.getGCodeExtension(), profile.getGCodeExtension(), profile.getGCodeExtension()[0:2]))
        if dlg.ShowModal() == wx.ID_OK:
            gcodeFile = dlg.GetPath()
            f = open(gcodeFile, 'r')
            hasProfile = False
            for line in f:
                if line.startswith(';CURA_PROFILE_STRING:'):
                    profile.setProfileFromString(line[line.find(':')+1:].strip())
                    if ';{profile_string}' not in profile.getAlterationFile('end.gcode'):
                        profile.setAlterationFile('end.gcode', profile.getAlterationFile('end.gcode') + '\n;{profile_string}')
                    hasProfile = True
            if hasProfile:
                self.updateProfileToAllControls()
            else:
                wx.MessageBox(_("No profile found in GCode file.\nThis feature only works with GCode files made by Cura 12.07 or newer."), _("Profile load error"), wx.OK | wx.ICON_INFORMATION)
        dlg.Destroy()

    def OnSaveProfile(self, e):
        dlg=wx.FileDialog(self, _("Select profile file to save"), os.path.split(profile.getPreference('lastFile'))[0], style=wx.FD_SAVE)
        dlg.SetWildcard("ini files (*.ini)|*.ini")
        if dlg.ShowModal() == wx.ID_OK:
            profile_filename = dlg.GetPath()
            if not profile_filename.lower().endswith('.ini'): #hack for linux, as for some reason the .ini is not appended.
                profile_filename += '.ini'
            profile.saveProfile(profile_filename)
        dlg.Destroy()

    def OnSaveDifferences(self, e):
        dlg=wx.FileDialog(self, _("Select profile file to save"), os.path.split(profile.getPreference('lastFile'))[0], style=wx.FD_SAVE)
        dlg.SetWildcard("ini files (*.ini)|*.ini")
        if dlg.ShowModal() == wx.ID_OK:
            profile_filename = dlg.GetPath()
            if not profile_filename.lower().endswith('.ini'): #hack for linux, as for some reason the .ini is not appended.
                profile_filename += '.ini'
            profile.saveProfileDifferenceFromDefault(profile_filename)
        dlg.Destroy()

    def OnResetProfile(self, e):
        dlg = wx.MessageDialog(self, _("This will reset all profile settings to defaults.\nUnless you have saved your current profile, all settings will be lost!\nDo you really want to reset?"), _("Profile reset"), wx.YES_NO | wx.ICON_QUESTION)
        result = dlg.ShowModal() == wx.ID_YES
        dlg.Destroy()
        if result:
            profile.resetProfile()
            self.updateProfileToAllControls()

    def OnSimpleSwitch(self, e):
        profile.putPreference('startMode', 'Simple')
        self.updateSliceMode()

    def OnNormalSwitch(self, e):
        profile.putPreference('startMode', 'Normal')
        dlg = wx.MessageDialog(self, _("Copy the settings from quickprint to your full settings?\n(This will overwrite any full setting modifications you have)"), _("Profile copy"), wx.YES_NO | wx.ICON_QUESTION)
        result = dlg.ShowModal() == wx.ID_YES
        dlg.Destroy()
        if result:
            profile.resetProfile()
            for k, v in self.simpleSettingsPanel.getSettingOverrides().items():
                if profile.getMachineSetting('machine_type').startswith('ultimaker2+'):
                    if k == 'nozzle_size':
                        v = round(float(v) * 1.14, 2)
                    if k == 'wall_thickness':
                        v = round(float(v) * 1.14, 1)
                profile.putProfileSetting(k, v)
            self.updateProfileToAllControls()
        self.updateSliceMode()

    def OnDefaultMarlinFirmware(self, e):
        firmwareInstall.InstallFirmware(self)

    def OnCustomFirmware(self, e):
        if profile.getMachineSetting('machine_type').startswith('ultimaker'):
            wx.MessageBox(_("Warning: Installing a custom firmware does not guarantee that you machine will function correctly, and could damage your machine."), _("Firmware update"), wx.OK | wx.ICON_EXCLAMATION)
        if sys.platform.startswith('win'):
            self._dir = os.path.expanduser('~') + '\Downloads'
        elif sys.platform.startswith('darwin'):
            self._dir = os.path.expanduser('~') + '/Downloads/'
        dlg=wx.FileDialog(self, _("Open firmware to upload"), self._dir, style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST)
        dlg.SetWildcard("HEX file (*.hex)|*.hex;*.HEX")
        if dlg.ShowModal() == wx.ID_OK:
            filename = dlg.GetPath()
            dlg.Destroy()
            if not(os.path.exists(filename)):
                return
            #For some reason my Ubuntu 10.10 crashes here.
            machineCom.InstallFirmware(self, filename)

    def OnUpdateHardwareFirmware(self, e):
        configFirmware.ConfigFirmware()

    def OnAddNewMachine(self, e):
        self.Hide()
        configWizard.ConfigWizard(True)
        self.Show()
        self.reloadSettingPanels()
        self.updateMachineMenu()

    def OnSelectMachine(self, index):
        profile.setActiveMachine(index)
        self.reloadSettingPanels()

    def OnBedLevelWizard(self, e):
        configWizard.bedLevelWizard()

    def OnHeadOffsetWizard(self, e):
        configWizard.headOffsetWizard()

    def OnExpertOpen(self, e):
        ecw = expertConfig.expertConfigWindow(lambda : self.scene.sceneUpdated())
        ecw.Centre()
        ecw.Show()

    def OnMinecraftImport(self, e):
        mi = minecraftImport.minecraftImportWindow(self)
        mi.Centre()
        mi.Show(True)

    def OnPIDDebugger(self, e):
        debugger = pidDebugger.debuggerWindow(self)
        debugger.Centre()
        debugger.Show(True)

    def OnAutoFirmwareUpdate(self, e):
        dlg=wx.FileDialog(self, _("Open firmware to upload"), os.path.split(profile.getPreference('lastFile'))[0], style=wx.FD_OPEN|wx.FD_FILE_MUST_EXIST)
        dlg.SetWildcard("HEX file (*.hex)|*.hex;*.HEX")
        if dlg.ShowModal() == wx.ID_OK:
            filename = dlg.GetPath()
            dlg.Destroy()
            if not(os.path.exists(filename)):
                return
            #For some reason my Ubuntu 10.10 crashes here.
            installer = firmwareInstall.AutoUpdateFirmware(self, filename)

    def onCopyProfileClipboard(self, e):
        try:
            if not wx.TheClipboard.IsOpened():
                wx.TheClipboard.Open()
                clipData = wx.TextDataObject()
                self.lastTriedClipboard = profile.getProfileString()
                profileString = profile.insertNewlines("CURA_PROFILE_STRING:" + self.lastTriedClipboard)
                clipData.SetText(profileString)
                wx.TheClipboard.SetData(clipData)
                wx.TheClipboard.Close()
        except:
            print "Could not write to clipboard, unable to get ownership. Another program is using the clipboard."

    def OnCheckForUpdate(self, e):
        newVersion = version.checkForNewVersion()
        if newVersion is not None:
            if wx.MessageBox(_("A new version of Cura-BCN3D is available, would you like to download?"), _("New version available"), wx.YES_NO | wx.ICON_INFORMATION) == wx.YES:
                webbrowser.open(newVersion)
        elif newVersion is None:
            wx.MessageBox(_("You are running the latest version of Cura-BCN3D!"), _("Awesome!"), wx.ICON_INFORMATION)
 
    def OnAbout(self, e):
        aboutBox = aboutWindow.aboutWindow()
        aboutBox.Centre()
        aboutBox.Show()

    def OnClose(self, e):
        profile.saveProfile(profile.getDefaultProfilePath(), True)

        # Save the window position, size & state from the preferences file
        profile.putPreference('window_maximized', self.IsMaximized())
        if not self.IsMaximized() and not self.IsIconized():
            (posx, posy) = self.GetPosition()
            profile.putPreference('window_pos_x', posx)
            profile.putPreference('window_pos_y', posy)
            (width, height) = self.GetSize()
            profile.putPreference('window_width', width)
            profile.putPreference('window_height', height)

            # Save normal sash position.  If in normal mode (!simple mode), get last position of sash before saving it...
            isSimple = profile.getPreference('startMode') == 'Simple'
            if not isSimple:
                self.normalSashPos = self.splitter.GetSashPosition()
            profile.putPreference('window_normal_sash', self.normalSashPos)

        #HACK: Set the paint function of the glCanvas to nothing so it won't keep refreshing. Which can keep wxWidgets from quiting.
        print "Closing down"
        self.scene.OnPaint = lambda e : e
        self.scene._engine.cleanup()
        self.Destroy()

    def OnQuit(self, e):
        self.Close()

class normalSettingsPanel(configBase.configPanelBase):
    "Main user interface window"
    def __init__(self, parent, callback = None):
        super(normalSettingsPanel, self).__init__(parent, callback)

        #Main tabs
        self.nb = wx.Notebook(self)
        self.SetSizer(wx.BoxSizer(wx.HORIZONTAL))
        self.GetSizer().Add(self.nb, 1, wx.EXPAND)

        (left, right, self.printPanel) = self.CreateDynamicConfigTab(self.nb, _('Basic'))
        self._addSettingsToPanels('basic', left, right)
        self.SizeLabelWidths(left, right)

        (left, right, self.advancedPanel) = self.CreateDynamicConfigTab(self.nb, _('Advanced'))
        self._addSettingsToPanels('advanced', left, right)
        self.SizeLabelWidths(left, right)

        #Plugin page
        self.pluginPanel = pluginPanel.pluginPanel(self.nb, callback)
        self.nb.AddPage(self.pluginPanel, _("Plugins"))

        #Alteration page
        if profile.getMachineSetting('gcode_flavor') == 'UltiGCode':
            self.alterationPanel = None
        else:
            self.alterationPanel = alterationPanel.alterationPanel(self.nb, callback)
            self.nb.AddPage(self.alterationPanel, "Start/End-GCode")

        self.Bind(wx.EVT_SIZE, self.OnSize)

        self.nb.SetSize(self.GetSize())
        self.UpdateSize(self.printPanel)
        self.UpdateSize(self.advancedPanel)

    def _addSettingsToPanels(self, category, left, right):
        count = len(profile.getSubCategoriesFor(category)) + len(profile.getSettingsForCategory(category))

        p = left
        n = 0
        for title in profile.getSubCategoriesFor(category):
            n += 1 + len(profile.getSettingsForCategory(category, title))
            if n > count / 2:
                p = right
            configBase.TitleRow(p, _(title))
            for s in profile.getSettingsForCategory(category, title):
                configBase.SettingRow(p, s.getName())

    def SizeLabelWidths(self, left, right):
        leftWidth = self.getLabelColumnWidth(left)
        rightWidth = self.getLabelColumnWidth(right)
        maxWidth = max(leftWidth, rightWidth)
        self.setLabelColumnWidth(left, maxWidth)
        self.setLabelColumnWidth(right, maxWidth)

    def OnSize(self, e):
        # Make the size of the Notebook control the same size as this control
        self.nb.SetSize(self.GetSize())

        # Propegate the OnSize() event (just in case)
        e.Skip()

        # Perform out resize magic
        self.UpdateSize(self.printPanel)
        self.UpdateSize(self.advancedPanel)

    def UpdateSize(self, configPanel):
        sizer = configPanel.GetSizer()

        # Pseudocde
        # if horizontal:
        #     if width(col1) < best_width(col1) || width(col2) < best_width(col2):
        #         switch to vertical
        # else:
        #     if width(col1) > (best_width(col1) + best_width(col1)):
        #         switch to horizontal
        #

        col1 = configPanel.leftPanel
        colSize1 = col1.GetSize()
        colBestSize1 = col1.GetBestSize()
        col2 = configPanel.rightPanel
        colSize2 = col2.GetSize()
        colBestSize2 = col2.GetBestSize()

        orientation = sizer.GetOrientation()

        if orientation == wx.HORIZONTAL:
            if (colSize1[0] <= colBestSize1[0]) or (colSize2[0] <= colBestSize2[0]):
                configPanel.Freeze()
                sizer = wx.BoxSizer(wx.VERTICAL)
                sizer.Add(configPanel.leftPanel, flag=wx.EXPAND)
                sizer.Add(configPanel.rightPanel, flag=wx.EXPAND)
                configPanel.SetSizer(sizer)
                #sizer.Layout()
                configPanel.Layout()
                self.Layout()
                configPanel.Thaw()
        else:
            if max(colSize1[0], colSize2[0]) > (colBestSize1[0] + colBestSize2[0]):
                configPanel.Freeze()
                sizer = wx.BoxSizer(wx.HORIZONTAL)
                sizer.Add(configPanel.leftPanel, proportion=1, border=35, flag=wx.EXPAND)
                sizer.Add(configPanel.rightPanel, proportion=1, flag=wx.EXPAND)
                configPanel.SetSizer(sizer)
                #sizer.Layout()
                configPanel.Layout()
                self.Layout()
                configPanel.Thaw()

    def updateProfileToControls(self):
        super(normalSettingsPanel, self).updateProfileToControls()
        if self.alterationPanel is not None:
            self.alterationPanel.updateProfileToControls()
        self.pluginPanel.updateProfileToControls()


class simpleModeSigma(configBase.configPanelBase):
    "Main user interface window for Quickprint mode"
    def __init__(self, parent, callback = None):
        super(simpleModeSigma, self).__init__(parent, callback)

        machine_type = profile.getMachineSetting('machine_type')

        # Main tabs
        self.nb = wx.Notebook(self)
        self.SetSizer(wx.BoxSizer(wx.HORIZONTAL))
        self.GetSizer().Add(self.nb, 1, wx.EXPAND)

        #self._callback = callback

        self.pluginPanel = mexPanel.MexPanel(self.nb, callback)
        self.nb.AddPage(self.pluginPanel, _("MEX"))

        self.alterationPanel = idexPanel.IdexPanel(self.nb, callback)
        self.nb.AddPage(self.alterationPanel, "IDEX")

        self.Bind(wx.EVT_SIZE, self.OnSize)

        self.nb.SetSize(self.GetSize())

    def OnSize(self, e):
        # Make the size of the Notebook control the same size as this control
        self.nb.SetSize(self.GetSize())

        # Propegate the OnSize() event (just in case)
        e.Skip()

    def UpdateSize(self, configPanel):
        sizer = configPanel.GetSizer()

        # Pseudocde
        # if horizontal:
        #     if width(col1) < best_width(col1) || width(col2) < best_width(col2):
        #         switch to vertical
        # else:
        #     if width(col1) > (best_width(col1) + best_width(col1)):
        #         switch to horizontal
        #

        col1 = configPanel.leftPanel
        colSize1 = col1.GetSize()
        colBestSize1 = col1.GetBestSize()
        col2 = configPanel.rightPanel
        colSize2 = col2.GetSize()
        colBestSize2 = col2.GetBestSize()

        orientation = sizer.GetOrientation()

        if orientation == wx.HORIZONTAL:
            if (colSize1[0] <= colBestSize1[0]) or (colSize2[0] <= colBestSize2[0]):
                configPanel.Freeze()
                sizer = wx.BoxSizer(wx.VERTICAL)
                sizer.Add(configPanel.leftPanel, flag=wx.EXPAND)
                sizer.Add(configPanel.rightPanel, flag=wx.EXPAND)
                configPanel.SetSizer(sizer)
                # sizer.Layout()
                configPanel.Layout()
                self.Layout()
                configPanel.Thaw()
        else:
            if max(colSize1[0], colSize2[0]) > (colBestSize1[0] + colBestSize2[0]):
                configPanel.Freeze()
                sizer = wx.BoxSizer(wx.HORIZONTAL)
                sizer.Add(configPanel.leftPanel, proportion=1, border=35, flag=wx.EXPAND)
                sizer.Add(configPanel.rightPanel, proportion=1, flag=wx.EXPAND)
                configPanel.SetSizer(sizer)
                # sizer.Layout()
                configPanel.Layout()
                self.Layout()
                configPanel.Thaw()