558 lines
18 KiB
Python
Executable File
558 lines
18 KiB
Python
Executable File
#! /usr/bin/python
|
|
# -*- coding:utf-8 -*-
|
|
# © 2012 Skyler Lehmkuhl
|
|
# Released under the GPLv3. For more information, see gpl.txt.
|
|
|
|
import os, shutil, tarfile, tempfile, StringIO
|
|
|
|
#Uncomment to build on OS X
|
|
#import objc, AppKit, cPickle
|
|
|
|
#Uncomment to build on Windows
|
|
#import ctypes, ctypes.wintypes, win32print
|
|
|
|
#SVLGUI - my custom GUI wrapper to abstract the GUI
|
|
import svlgui
|
|
|
|
#swift_window - builds the application windows
|
|
import lightningbeam_windows
|
|
|
|
#pickle - used to save and open files
|
|
import pickle
|
|
|
|
#webbrowser - used to launch HTML5
|
|
import webbrowser
|
|
|
|
#misc_funcs - miscelleneous functions in a separate file so as not to clutter things up too much
|
|
import misc_funcs
|
|
|
|
#If we can import this, we are in the install directory. Mangle media paths accordingly.
|
|
try:
|
|
from distpath import media_path
|
|
except:
|
|
media_path = ""
|
|
|
|
#specify the current version and what version files it can still open
|
|
LIGHTNINGBEAM_VERSION = "1.0-alpha1"
|
|
LIGHTNINGBEAM_COMPAT = ["1.0-alpha1"]
|
|
|
|
#Global variables. Used to keep stuff together.
|
|
global root
|
|
global layers
|
|
|
|
def update_date():
|
|
return "Tue, January 10, 2012"
|
|
|
|
|
|
|
|
def onLoadFrames(self):
|
|
'''for i in range(2000):
|
|
if i%5==0:
|
|
j = box(i*16,0,16,32,svlgui.Color([0.5,0.5,0.5]))
|
|
self.add(j)
|
|
else:
|
|
j = box(i*16,0,16,32,svlgui.Color([1,1,1]))
|
|
self.add(j)'''
|
|
def onClickFrame(self, x, y):
|
|
root.descendItem().activelayer.frames[root.descendItem().activelayer.currentframe].actions = MainWindow.scriptwindow.text
|
|
root.descendItem().activeframe = int(x/16)
|
|
print ">>>>>> ", x, y
|
|
MainWindow.stage.draw()
|
|
MainWindow.scriptwindow.text = str(root.descendItem().activelayer.frames[root.descendItem().activelayer.currentframe].actions)
|
|
def onKeyDownFrame(self, key):
|
|
root.descendItem().activelayer.frames[root.descendItem().activelayer.currentframe].actions = MainWindow.scriptwindow.text
|
|
if key in [" ", "s", "r", "e", "b"]:
|
|
svlgui.MODE=key
|
|
svlgui.set_cursor({" ":"arrow","s":"arrow","r":"crosshair","e":"crosshair",
|
|
"b":"arrow"}[key], MainWindow.stage)
|
|
misc_funcs.update_tooloptions()
|
|
elif key=="F6":
|
|
add_keyframe()
|
|
elif key=="F8":
|
|
convert_to_symbol()
|
|
MainWindow.scriptwindow.text = root.descendItem().activelayer.frames[root.descendItem().activelayer.currentframe].actions
|
|
def onMouseDownGroup(self, x, y):
|
|
self.activelayer.frames[self.activelayer.currentframe].actions = MainWindow.scriptwindow.text
|
|
if svlgui.MODE in [" ", "s"]:
|
|
if self.hitTest(x, y):
|
|
self.clicked = True
|
|
elif svlgui.MODE in ["r", "e", "p"]:
|
|
if svlgui.MODE=="r":
|
|
#I can't remember what the 'c' stands for...
|
|
self.cshape = box(x, y, 0, 0)
|
|
elif svlgui.MODE=="e":
|
|
self.cshape = ellipse(x, y, 0, 0)
|
|
elif svlgui.MODE=="p":
|
|
self.cshape = shape(x, y)
|
|
#self.cshape.rotation = 5
|
|
self.cshape.initx,self.cshape.inity = x, y
|
|
self.add(self.cshape)
|
|
self.cshape.onMouseDown = onMouseDownObj
|
|
self.cshape.onMouseMove = onMouseMoveObj
|
|
self.cshape.onMouseDrag = onMouseDragObj
|
|
self.cshape.onMouseUp = onMouseUpObj
|
|
self.cshape.onKeyDown = onKeyDownObj
|
|
self.clicked = True
|
|
MainWindow.scriptwindow.text = self.activelayer.frames[self.activelayer.currentframe].actions
|
|
elif svlgui.MODE in ["t"]:
|
|
self.ctext = svlgui.Text("Mimimi",x,y)
|
|
self.ctext.onMouseDown = onMouseDownText
|
|
self.ctext.onMouseDrag = onMouseDragText
|
|
self.ctext.onMouseUp = onMouseUpText
|
|
self.add(self.ctext)
|
|
self.ctext = None
|
|
MainWindow.docbox.setvisible(True)
|
|
MainWindow.textbox.setvisible(False)
|
|
|
|
def onMouseDownObj(self, x, y):
|
|
MainWindow.scriptwindow.text = root.descendItem().activelayer.frames[root.descendItem().activelayer.currentframe].actions
|
|
self.clicked = True
|
|
self.initx,self.inity = x-self.x, y-self.y
|
|
if svlgui.MODE == "b":
|
|
self.filled = True
|
|
self.fillcolor = svlgui.FILLCOLOR
|
|
def onMouseDownText(self,x,y):
|
|
MainWindow.scriptwindow.text = root.descendItem().activelayer.frames[root.descendItem().activelayer.currentframe].actions
|
|
self.clicked = True
|
|
self.initx, self.inity = x-self.x, y-self.y
|
|
MainWindow.docbox.setvisible(False)
|
|
MainWindow.textbox.setvisible(True)
|
|
svlgui.CURRENTTEXT = self.obj
|
|
print "Height", MainWindow.textbox.height
|
|
def onMouseDownFrame(self, x, y):
|
|
pass
|
|
def onMouseUpGroup(self, x, y):
|
|
self.clicked = False
|
|
if svlgui.MODE in ["r", "e"]:
|
|
self.cshape = None
|
|
elif svlgui.MODE=="p":
|
|
print len(self.cshape.shapedata)
|
|
self.cshape.shapedata = misc_funcs.simplify_shape(self.cshape.shapedata, svlgui.PMODE.split()[-1],1)
|
|
print len(self.cshape.shapedata)
|
|
self.cshape = None
|
|
MainWindow.stage.draw()
|
|
def onMouseUpObj(self, x, y):
|
|
self.clicked = False
|
|
def onMouseUpText(self, x, y):
|
|
self.clicked = False
|
|
def onMouseMoveGroup(self, x, y):
|
|
pass
|
|
#This is for testing rotation. Comment out before any commit!
|
|
#root.rotation+=0.01
|
|
def onMouseMoveObj(self, x, y):
|
|
pass
|
|
def onMouseDragGroup(self, x, y):
|
|
if svlgui.MODE in [" ", "s"]:
|
|
self.x = x
|
|
self.y = y
|
|
elif svlgui.MODE == "r":
|
|
sd = self.cshape.shapedata
|
|
x=x-self.cshape.initx
|
|
y=y-self.cshape.inity
|
|
self.cshape.shapedata = [sd[0],["L",x,sd[0][2]],["L",x,y],["L",sd[0][1],y],sd[4]]
|
|
elif svlgui.MODE == "e":
|
|
sd = self.cshape.shapedata
|
|
x=x-self.cshape.initx
|
|
y=y-self.cshape.inity
|
|
self.cshape.shapedata = [["M",x/2,0],["C",4*x/5,0,x,y/5,x,y/2],["C",x,4*y/5,4*x/5,y,x/2,y],["C",x/5,y,0,4*y/5,0,y/2],["C",0,y/5,x/5,0,x/2,0]]
|
|
elif svlgui.MODE == "p":
|
|
self.cshape.shapedata.append(["L",x-self.cshape.initx,y-self.cshape.inity])
|
|
def onMouseDragObj(self, x, y):
|
|
self.x = x-self.initx
|
|
self.y = y-self.inity
|
|
def onMouseDragText(self, x, y):
|
|
self.x = x-self.initx
|
|
self.y = y-self.inity
|
|
|
|
def onKeyDownGroup(self, key):
|
|
if not svlgui.EDITING:
|
|
if key in [" ", "s", "r", "e", "b", "p"]:
|
|
svlgui.MODE=key
|
|
svlgui.set_cursor({" ":"arrow","s":"arrow","r":"crosshair","e":"crosshair",
|
|
"b":"arrow","p":"arrow"}[key], MainWindow.stage)
|
|
misc_funcs.update_tooloptions()
|
|
elif key=="F6":
|
|
add_keyframe()
|
|
elif key=="F8":
|
|
convert_to_symbol()
|
|
else:
|
|
if not key=="escape":
|
|
pass
|
|
else:
|
|
svlgui.EDITING=False
|
|
def onKeyDownObj(self, key):
|
|
if key in ("delete", "backspace"):
|
|
del self.parent[self.parent.index(self)] # Need to clean up deletion
|
|
elif key in [" ", "s", "r", "e", "b", "p"]:
|
|
svlgui.MODE=key
|
|
svlgui.set_cursor({" ":"arrow","s":"arrow","r":"crosshair","e":"crosshair",
|
|
"b":"arrow","p":"arrow"}[key], MainWindow.stage)
|
|
misc_funcs.update_tooloptions()
|
|
elif key=="F6":
|
|
add_keyframe()
|
|
elif key=="F8":
|
|
convert_to_symbol()
|
|
|
|
def create_sc(root):
|
|
#retval = ".flash bbox="+str(svlgui.WIDTH)+"x"+str(svlgui.HEIGHT)+" background=#ffffff \
|
|
#fps="+str(svlgui.FRAMERATE)+"\n"+root.print_sc()+".end"
|
|
retval = ".flash bbox="+str(svlgui.WIDTH)+"x"+str(svlgui.HEIGHT)+" background=#ffffff \
|
|
fps="+str(svlgui.FRAMERATE)+"\n"+"".join([i.print_sc() for i in svlgui.Library])+root.print_sc()+".end"
|
|
return retval
|
|
def run_file(self=None):
|
|
global root
|
|
print "RUNNING"
|
|
root.descendItem().activelayer.frames[root.descendItem().activelayer.currentframe].actions = MainWindow.scriptwindow.text
|
|
open(os.getenv('HOME')+"/test.sc", "w").write(create_sc(root))
|
|
svlgui.execute("swfc/swfc_"+svlgui.PLATFORM+" "+os.getenv('HOME')+"/test.sc -o "+os.getenv('HOME')+"/test.swf")
|
|
#TODO: Make this cross-platform compatible
|
|
logloc = os.getenv('HOME')+"/Library/Preferences/Macromedia/Flash Player/Logs/flashlog.txt"
|
|
try:
|
|
logfile.close()
|
|
except:
|
|
pass
|
|
logfile = open(logloc,"w")
|
|
logfile.write("")
|
|
logfile.close()
|
|
outputwin = svlgui.Window("Output")
|
|
outputwin.resize(200,500)
|
|
outputtext = svlgui.TextView(False)
|
|
outputwin.add(outputtext)
|
|
logfile = open(logloc, "r")
|
|
def updatetrace(outputtext):
|
|
try:
|
|
outputtext.text+=logfile.readline()
|
|
outputtext.scroll_bottom() # this doesn't work
|
|
except:
|
|
pass
|
|
r = misc_funcs.RepeatTimer(0.02, updatetrace, args=[outputtext])
|
|
print dir(outputwin.window)
|
|
r.daemon = True
|
|
r.start()
|
|
if svlgui.PLATFORM=="osx":
|
|
osx_flash_player_loc = "/Applications/Flash\ Player\ Debugger.app"
|
|
success = svlgui.execute("open -a "+osx_flash_player_loc+" "+os.getenv('HOME')+"/test.swf")
|
|
if not success:
|
|
svlgui.alert("Oops! Didn't work. I probably couldn't find your Flash debugger!")
|
|
elif svlgui.PLATFORM=='win32':
|
|
win_flash_player_loc = ""
|
|
svlgui.execute('start '+win_flash_player_loc+" test.swf")
|
|
elif svlgui.PLATFORM.startswith('linux'):
|
|
linux_flash_player_loc = ""
|
|
svlgui.execute('xdg-open '+linux_flash_player_loc+" test.swf")
|
|
def create_html5(root):
|
|
retval = "<head>\n\
|
|
<style type=\"text/css\">\n\
|
|
canvas { \n\
|
|
border: none; position:absolute; top:0;left:0;\n\
|
|
visibility: hidden; }\n\
|
|
</style>\n\
|
|
</head>\n\
|
|
<body>\n\
|
|
<div id='events'>\n\
|
|
<canvas id=\"canvas1\" width="+str(svlgui.WIDTH)+" height="+str(svlgui.HEIGHT)+" ></canvas>\n\
|
|
<canvas id=\"canvas2\" width="+str(svlgui.WIDTH)+" height="+str(svlgui.HEIGHT)+"></canvas>\n\
|
|
</div>\n\
|
|
<script>\n\
|
|
//Setup\nvar fps = "+str(svlgui.FRAMERATE)+";\n</script>\n\
|
|
<script src=\"base.js\">\n\
|
|
</script>\n\
|
|
<script>\n"+"".join([i.print_html() for i in svlgui.Library])+root.print_html()+"\n\
|
|
document.onmousemove = function(e){_root._xmouse=e.pageX;_root._ymouse=e.pageY}\n\
|
|
document.onmousedown = function(e){Event.doEvent(\"onMouseDown\")}\n\
|
|
document.onkeydown = function(e){Key.press(e);Event.doEvent(\"onKeyDown\")}\n\
|
|
document.onkeyup = function(e){Key.release(e);Event.doEvent(\"onKeyUp\")}\n\
|
|
</script>\n</body>\n</html>"
|
|
return retval
|
|
def run_html(self=None):
|
|
global root
|
|
print "RUNNING"
|
|
root.descendItem().activelayer.frames[root.descendItem().activelayer.currentframe].actions = MainWindow.scriptwindow.text
|
|
open(os.getenv('HOME')+"/test.html", "w").write(create_html5(root))
|
|
try:
|
|
shutil.copyfile("base.js",os.getenv('HOME')+"/base.js")
|
|
except IOError:
|
|
svlgui.alert("Couldn't copy base.js to "+os.getenv('HOME')+"/base.js!")
|
|
webbrowser.open("file://"+os.getenv('HOME')+"/test.html")
|
|
|
|
|
|
|
|
def box(x, y, width, height, fill=None):
|
|
global objects
|
|
box = svlgui.Shape(x, y)
|
|
box.shapedata = [["M",0,0],["L",width,0],["L",width,height],["L",0,height],["L",0,0]]
|
|
box.onMouseDown = onMouseDownObj
|
|
box.onMouseUp = onMouseUpObj
|
|
if fill:
|
|
box.fillcolor = fill
|
|
box.linecolor = svlgui.Color([0,0,0,0])
|
|
box.filled = True
|
|
return box
|
|
def ellipse(x, y, width, height, fill=svlgui.FILLCOLOR):
|
|
global objects
|
|
ellipse = svlgui.Shape(x, y)
|
|
ellipse.shapedata = [["M",width/2,0],["C",4*width/5,0,width,height/5,width,height/2], ["C",width,4*height/5,4*width/5,height,width/2,height], ["C",width/5,height,0,4*height/5,0,height/2], ["C",0,height/5,width/5,0,width/2,0]]
|
|
|
|
# must figure out shapedata...
|
|
return ellipse
|
|
def shape(x, y, fill=None):
|
|
shape = svlgui.Shape(x,y)
|
|
shape.shapedata = [["M",0,0]]
|
|
return shape
|
|
|
|
root = svlgui.Group(skipl=True)
|
|
root.name = "_root"
|
|
root.level = True
|
|
root.onMouseDown = onMouseDownGroup
|
|
root.onMouseUp = onMouseUpGroup
|
|
root.onMouseMove = onMouseMoveGroup
|
|
root.onMouseDrag = onMouseDragGroup
|
|
root.onKeyDown = onKeyDownGroup
|
|
|
|
svlgui.root = root
|
|
|
|
e=ellipse(100,100,100,50,None)
|
|
e.onMouseDown = onMouseDownObj
|
|
e.onMouseMove = onMouseMoveObj
|
|
e.onMouseDrag = onMouseDragObj
|
|
e.onMouseUp = onMouseUpObj
|
|
e.onKeyDown = onKeyDownObj
|
|
root.add(e)
|
|
|
|
|
|
|
|
|
|
if svlgui.SYSTEM == "gtk":
|
|
overlaywindow = svlgui.OverlayWindow()
|
|
MainWindow = lightningbeam_windows.MainWindow()
|
|
elif svlgui.SYSTEM=="osx":
|
|
MainWindow = lightningbeam_windows.MainWindowOSX()
|
|
elif svlgui.SYSTEM=="html":
|
|
MainWindow = lightningbeam_windows.MainWindowHTML()
|
|
elif svlgui.SYSTEM=="pyglet":
|
|
MainWindow = lightningbeam_windows.MainWindowOSX()
|
|
elif svlgui.SYSTEM=="android":
|
|
MainWindow = lightningbeam_windows.MainWindowAndroid()
|
|
MainWindow.stage.add(root, 0,0)
|
|
svlgui.FOCUS = MainWindow.stage
|
|
layers = svlgui.Group(skipl=True)
|
|
b = svlgui.Image(media_path+"media/object_active.png",0,0,True,MainWindow.layerbox,16,1,True)
|
|
layers.add(b)
|
|
MainWindow.layerbox.add(layers,0,0)
|
|
|
|
#frames = svlgui.Group(onload=onLoadFrames,skipl=True)
|
|
#b = svlgui.Image("media/keyframe_active.png",0,0,True,MainWindow.timelinebox,16,1,True)
|
|
#frames.add(b)
|
|
#frames.onMouseDown = onClickFrame
|
|
#frames.onKeyDown = onKeyDownFrame
|
|
#MainWindow.timelinebox.add(frames,0,0)
|
|
MainWindow.timelinebox.root = root
|
|
MainWindow.timelinebox.onMouseDown = onClickFrame
|
|
|
|
|
|
def new_file(widget=None):
|
|
global root
|
|
MainWindow.stage.delete(root)
|
|
root = svlgui.Group()
|
|
root.level = True
|
|
root.onMouseDown = onMouseDownGroup
|
|
root.onMouseUp = onMouseUpGroup
|
|
root.onMouseMove = onMouseMoveGroup
|
|
MainWindow.stage.add(root,0,0)
|
|
def open_file(widget=None):
|
|
global root
|
|
MainWindow.stage.delete(root)
|
|
shutil.rmtree(svlgui.SECURETEMPDIR)
|
|
thetarfile = tarfile.open(fileobj=svlgui.file_dialog("open").open("rb"),mode="r:gz")
|
|
basefile = thetarfile.extractfile("basefile")
|
|
root, svlgui.Library = pickle.load(basefile)
|
|
svlgui.SECURETEMPDIR = tempfile.mkdtemp()
|
|
thetarfile.extractall(path=svlgui.SECURETEMPDIR)
|
|
for i in svlgui.Library:
|
|
if i.type=="Image":
|
|
i.path = svlgui.SECURETEMPDIR+"/"+i.path.split(os.sep)[-1]
|
|
i.set_image(i.path)
|
|
if not hasattr(i, 'iname'):
|
|
i.iname = None
|
|
MainWindow.stage.add(root, 0, 0)
|
|
MainWindow.stage.draw()
|
|
MainWindow.timelinebox.root = root
|
|
MainWindow.timelinebox.draw()
|
|
thetarfile.close()
|
|
def open_sc_file(widget=None):
|
|
pass
|
|
def save_file(widget=None):
|
|
data = pickle.dumps((root,svlgui.Library))
|
|
tarinfo = tarfile.TarInfo('basefile')
|
|
tarinfo.size = len(data)
|
|
if svlgui.FILE.name.startswith(svlgui.TEMPDIR):
|
|
thetarfile = tarfile.open(fileobj=svlgui.file_dialog("save").open('wb'),mode="w:gz")
|
|
print thetarfile.name
|
|
else:
|
|
thetarfile = tarfile.open(svlgui.FILE.name,mode="w:gz")
|
|
thetarfile.addfile(tarinfo, StringIO.StringIO(data))
|
|
#Save the path so we can come back here
|
|
lastpath = os.path.abspath(".")
|
|
for i in svlgui.Library:
|
|
if i.type=="Image":
|
|
print "i.path: ",i.path
|
|
try:
|
|
os.chdir(os.sep.join(i.path.split(os.sep)[:-1]) or i.origpath)
|
|
i.path = i.path.split(os.sep)[-1]
|
|
thetarfile.add(i.path.split(os.sep)[-1])
|
|
except OSError:
|
|
tmpdir = tempfile.mkdtemp()
|
|
os.chdir(tmpdir)
|
|
i.pilimage.save(i.path)
|
|
thetarfile.add(i.path)
|
|
os.remove(i.path)
|
|
os.chdir(lastpath)
|
|
thetarfile.close()
|
|
svlgui.FILE = thetarfile
|
|
#thetarfile.close()
|
|
def save_file_as(widget=None):
|
|
pass
|
|
def import_to_stage(widget=None):
|
|
thefile = svlgui.file_dialog("open",None,["jpg","png","bmp"]).path
|
|
im = svlgui.Image(thefile)
|
|
im.onMouseDown = onMouseDownObj
|
|
im.onMouseMove = onMouseMoveObj
|
|
im.onMouseDrag = onMouseDragObj
|
|
im.onMouseUp = onMouseUpObj
|
|
im.onKeyDown = onKeyDownObj
|
|
root.descendItem().add(im)
|
|
MainWindow.stage.draw()
|
|
def import_to_library(widget=None):
|
|
pass
|
|
|
|
def quit(widget):
|
|
svlgui.quit()
|
|
|
|
|
|
def add_keyframe(widget=None):
|
|
print "af> ", root.descendItem().activeframe
|
|
root.descendItem().add_frame(True)
|
|
MainWindow.timelinebox.draw()
|
|
def add_layer(widget=None):
|
|
root.descendItem().add_layer(root.descendItem()._al)
|
|
layers.add(svlgui.Image(media_path+"media/object_active.png",0,root.descendItem().layers.index(root.descendItem().activelayer)*32,True,MainWindow.layerbox,16,1,True))
|
|
print root.descendItem().layers.index(root.descendItem().activelayer)*32
|
|
#MainWindow.layerbox.draw()
|
|
def delete_layer(widget=None):
|
|
root.descendItem().delete_layer(root.descendItem()._al)
|
|
#layers.delete(box(0,(root.layers.index(root.activelayer))*32,128,32,svlgui.Color("media/object_inactive.png")))
|
|
MainWindow.timelineref.draw()
|
|
|
|
def send_to_back(widget=None):
|
|
rac = root.descendItem().activelayer.currentFrame()
|
|
index = rac.index(root.descendItem().activelayer.currentselect)
|
|
if index>0:
|
|
a = rac[:index]
|
|
b = rac[index+1:]
|
|
del rac[:index]
|
|
del rac[1:]
|
|
[rac.append(i) for i in a]
|
|
[rac.append(i) for i in b]
|
|
MainWindow.stage.draw()
|
|
|
|
def send_backward(widget=None):
|
|
rac = root.descendItem().activelayer.currentFrame()
|
|
index = rac.index(root.descendItem().activelayer.currentselect)
|
|
if index>0:
|
|
rac[index-1], rac[index] = rac[index], rac[index-1]
|
|
MainWindow.stage.draw()
|
|
|
|
def bring_forward(widget=None):
|
|
rac = root.descendItem().activelayer.currentFrame()
|
|
index = rac.index(root.descendItem().activelayer.currentselect)
|
|
if index+1<len(rac):
|
|
rac[index+1], rac[index] = rac[index], rac[index+1]
|
|
MainWindow.stage.draw()
|
|
|
|
def bring_to_front(widget=None):
|
|
rac = root.descendItem().activelayer.currentFrame()
|
|
index = rac.index(root.descendItem().activelayer.currentselect)
|
|
if index<len(rac):
|
|
a = rac[index]
|
|
del rac[index]
|
|
rac.append(a)
|
|
MainWindow.stage.draw()
|
|
|
|
def convert_to_symbol(widget=None):
|
|
if not root.descendItem().activelayer.currentselect:
|
|
svlgui.alert("No object selected!")
|
|
return
|
|
else:
|
|
svlgui.ConvertToSymbolWindow(root)
|
|
MainWindow.stage.draw()
|
|
|
|
def about(widget=None):
|
|
svlgui.alert("Lightningbeam v1.0-alpha1\nLast Updated: "+update_date()+
|
|
"\nCreated by: Skyler Lehmkuhl\nBased on SWIFT")
|
|
|
|
def preferences(widget=None):
|
|
prefwin = svlgui.PreferencesWindow()
|
|
|
|
|
|
svlgui.menufuncs([["File",
|
|
("New...", new_file,"<Control>N"),
|
|
("Open", open_file,"<Control>O"),
|
|
("Open .sc", open_sc_file),
|
|
("Save",save_file,"<Control>S"),
|
|
("Save As", save_file_as,"<Shift><Control>S"),
|
|
"Publish",
|
|
("Quit",quit,"<Control>Q")],
|
|
["Edit",
|
|
"Undo",
|
|
"Redo",
|
|
"Cut",
|
|
"Copy",
|
|
"Paste",
|
|
"Delete",
|
|
("Preferences",preferences,"")],
|
|
["Timeline",
|
|
("Add Keyframe",add_keyframe,"F6"),
|
|
"Add Blank Keyframe",
|
|
("Add Layer",add_layer,"<Shift><Control>N"),
|
|
("Delete Layer",delete_layer,"<Shift><Control>Delete")],
|
|
["Import",
|
|
("Import to Stage",import_to_stage,"/I"),
|
|
("Import to Library",import_to_library)],
|
|
["Export",
|
|
"Export .swf",
|
|
"Export HTML5",
|
|
"Export Native Application",
|
|
"Export .sc",
|
|
"Export Image",
|
|
"Export Video",
|
|
"Export .pdf",
|
|
"Export Animated GIF"],
|
|
["Tools",
|
|
("Execute",run_file,"/\r"),
|
|
("Execute as HTML5",run_html,"/\\")],
|
|
["Modify",
|
|
"Document",
|
|
("Convert to Symbol",convert_to_symbol,"F8"),
|
|
("Send to Back",send_to_back,"<Shift><Control>Down"),
|
|
("Send Backwards",send_backward,"<Control>Down"),
|
|
("Bring Forwards",bring_forward,"<Control>Up"),
|
|
("Bring to Front",bring_to_front,"<Shift><Control>Up")],
|
|
["Help",
|
|
"Lightningbeam Help",
|
|
"Actionscript Reference",
|
|
("About Lightningbeam...",about)]])
|
|
|
|
|
|
#open("/home/skyler/Desktop/test.sc","w").write(create_sc(root))
|
|
|
|
if not svlgui.SYSTEM=="android":
|
|
svlgui.main()
|
|
else:
|
|
import os
|
|
svlgui.droid.webViewShow('{0}/lightningbeam_ui.html'.format(str(os.curdir)))
|
|
while True:
|
|
result = svlgui.droid.eventWaitFor('pythonevent').result
|
|
svlgui.droid.eventClearBuffer()
|
|
print result
|
|
exec result["data"]
|