Fix pyserial 3.0 compatibility issue

[cura.git] / Cura / cura.py

diff --git a/Cura/cura.py b/Cura/cura.py
index 2172a4bfa5959fbbc2891f85f3f927dfff3a6310..c6d4e80b0d2cda886f8eb93fd7f7c1a3f35c8bb1 100644 (file)
--- a/Cura/cura.py
+++ b/Cura/cura.py
@@ -6,7 +6,6 @@ This page is in the table of contents.
 Cura is a AGPL tool chain to generate a GCode path for 3D printing. Older versions of Cura where based on Skeinforge.
 Versions up from 13.05 are based on a C++ engine called CuraEngine.
 """
-from __future__ import absolute_import
 __copyright__ = "Copyright (C) 2013 David Braam - Released under terms of the AGPLv3 License"
 
 from optparse import OptionParser
@@ -14,58 +13,83 @@ from optparse import OptionParser
 from Cura.util import profile
 
 def main():
+       """
+       Main Cura entry point. Parses arguments, and starts GUI or slicing process depending on the arguments.
+       """
        parser = OptionParser(usage="usage: %prog [options] <filename>.stl")
        parser.add_option("-i", "--ini", action="store", type="string", dest="profileini",
                help="Load settings from a profile ini file")
-       parser.add_option("-r", "--print", action="store", type="string", dest="printfile",
-               help="Open the printing interface, instead of the normal cura interface.")
        parser.add_option("-p", "--profile", action="store", type="string", dest="profile",
                help="Internal option, do not use!")
        parser.add_option("-s", "--slice", action="store_true", dest="slice",
                help="Slice the given files instead of opening them in Cura")
        parser.add_option("-o", "--output", action="store", type="string", dest="output",
                help="path to write sliced file to")
+       parser.add_option("--serialCommunication", action="store", type="string", dest="serialCommunication",
+               help="Start commandline serial monitor")
 
        (options, args) = parser.parse_args()
 
+       if options.serialCommunication:
+               from Cura import serialCommunication
+               port, baud = options.serialCommunication.split(':')
+               serialCommunication.startMonitor(port, baud)
+               return
+
+       print "load preferences from " + profile.getPreferencePath()
        profile.loadPreferences(profile.getPreferencePath())
+
        if options.profile is not None:
                profile.setProfileFromString(options.profile)
        elif options.profileini is not None:
                profile.loadProfile(options.profileini)
        else:
-               profile.loadProfile(profile.getDefaultProfilePath())
+               profile.loadProfile(profile.getDefaultProfilePath(), True)
 
-       if options.printfile is not None:
-               from Cura.gui import printWindow
-               printWindow.startPrintInterface(options.printfile)
-       elif options.slice is not None:
+       if options.slice is not None:
                from Cura.util import sliceEngine
                from Cura.util import objectScene
                from Cura.util import meshLoader
                import shutil
 
-               def commandlineProgessCallback(progress, ready):
-                       if progress >= 0 and not ready:
-                               print 'Preparing: %d%%' % (progress * 100)
+               def commandlineProgressCallback(progress):
+                       if progress >= 0:
+                               #print 'Preparing: %d%%' % (progress * 100)
+                               pass
                scene = objectScene.Scene()
-               slicer = sliceEngine.Slicer(commandlineProgessCallback)
+               scene.updateMachineDimensions()
+               engine = sliceEngine.Engine(commandlineProgressCallback)
                for m in meshLoader.loadMeshes(args[0]):
                        scene.add(m)
-               slicer.runSlicer(scene)
-               slicer.wait()
+               engine.runEngine(scene)
+               engine.wait()
 
-               if options.output:
-                       shutil.copyfile(slicer.getGCodeFilename(), options.output)
-                       print 'GCode file saved : %s' % options.output
-               else:
-                       shutil.copyfile(slicer.getGCodeFilename(), args[0] + '.gcode')
-                       print 'GCode file saved as: %s' % (args[0] + '.gcode')
+               if not options.output:
+                       options.output = args[0] + profile.getGCodeExtension()
+               with open(options.output, "wb") as f:
+                       gcode = engine.getResult().getGCode()
+                       while True:
+                               data = gcode.read()
+                               if len(data) == 0:
+                                       break
+                               f.write(data)
+               print 'GCode file saved : %s' % options.output
 
-               slicer.cleanup()
+               engine.cleanup()
        else:
                from Cura.gui import app
                app.CuraApp(args).MainLoop()
 
 if __name__ == '__main__':
+       import os
+       import sys
+
+       # On Windows, the PATH variable can cause the search path for dlls
+       # to give priority to dlls from other applications and it will cause
+       # the bundled python dlls not to be loaded.
+       # More specifically, anyone with Haskell Platform installed will not
+       # be able to launch Cura because glut32.dll from Haskell is incompatible
+       # with the bundled py-opengl and will cause Cura to crash
+       if sys.platform.startswith('win'):
+               os.environ['PATH'] = ''
        main()