# THIS FILE IS A PART OF VCStudio
# PYTHON 3
import os
import datetime
import threading
# GTK module ( Graphical interface
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from gi.repository import GLib
from gi.repository import Gdk
import cairo
# Own modules
from settings import settings
from settings import oscalls
from settings import talk
from project_manager import pm_project
from studio import analytics
from studio import studio_nodes
from studio import studio_dialogs
from studio import story
from studio import analytics
from studio import schedule
#UI modules
from UI import UI_elements
from UI import UI_color
def layer(win):
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
stf = datetime.datetime.now()
perfStat = []
###################################################################
# Making the layer
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, win.current['w'],
win.current['h'])
layer = cairo.Context(surface)
#text setting
layer.select_font_face("Monospace", cairo.FONT_SLANT_NORMAL, cairo.FONT_WEIGHT_NORMAL)
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Setup", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
UI_color.set(layer, win, "darker_parts")
UI_elements.roundrect(layer, win,
50,
50,
win.current["w"] - 100,
win.current["h"] - 80,
30)
# Little verion thing in the bottom corner
UI_color.set(layer, win, "testing_banner")
layer.set_font_size(15)
layer.move_to(win.current["w"]-80, win.current["h"] - 7)
layer.show_text(str(win.version))
# Hude analytics button on the top
def do():
win.cur = "/set"
win.url = "analytics"
UI_elements.roundrect(layer, win,
5,
5,
win.current["w"]-(win.current["w"]/3)+45,
40,
10,
do,
"analytics",
talk.text("analytics_tooltip"),
url="story_editor")
# Progressbar
UI_color.set(layer, win, "progress_background")
UI_elements.roundrect(layer, win,
55,
15,
win.current["w"]/3*2-10,
20,
10)
timepassed = 0.0
projectdone = 0.0
try:
timepassed = win.analytics["timepassed"]
projectdone = win.analytics["fraction"]
except:
pass
# Timepassed
UI_color.set(layer, win, "progress_time")
UI_elements.roundrect(layer, win,
55,
15,
(win.current["w"]/3*2-10)*timepassed,
20,
10)
# Project Done
UI_color.set(layer, win, "progress_active")
UI_elements.roundrect(layer, win,
55,
15,
(win.current["w"]/3*2-10)*projectdone,
20,
10)
# Separator
UI_color.set(layer, win, "node_background")
layer.move_to(win.current["w"]/3*2+55, 5)
layer.line_to(win.current["w"]/3*2+55, 45)
layer.stroke()
############ CURRENT TASK SCHEDULED #############
# FIRST WE NEED TO GET A LIST OF TASKS
# This is going to be a simplified version of the same stuff as in the
# scheduling. But since we don't care what date we are in and trying to
# get the oldest unchecked task. Here we go.
schedules = schedule.get_schedules(win.analytics["dates"])
new_date_format = "%Y/%m/%d"
today = datetime.datetime.strftime(datetime.datetime.today(), new_date_format)
slist = []
for date in schedules:
for item in schedules[date]:
if win.cur == item or not win.cur == "/set":
slist.append([date, item, schedules[date][item]])
# Now that we have our list we can start paring it the same way as in the
# scheduling. Only removing some unnesesary stuff.
foundtask = False
taskname = ""
taskurl = ""
taskcur = ""
for entry in slist:
if not foundtask:
for thing in entry[2]:
if thing[0][3] == "[Checked]":
continue # We do not care about those who are checked here.
elif thing[0][-1] != win.settings["Username"]:
continue # We do not care if it's not for us
else:
foundtask = True
# Here we are going to take out some data about this task
# First if it's not for today let's get a color for it
if entry[0] != "1997/07/30":
draw = False
if entry[0] < today:
UI_color.set(layer, win, "node_badfile") # The Red
draw = True
elif entry[0] > today:
UI_color.set(layer, win, "node_asset") # The Purple
draw = True
if draw:
UI_elements.roundrect(layer, win,
win.current["w"]/3*2+60,
5,
(win.current["w"]/3-65),
40,
10)
name = entry[1][entry[1].rfind("/")+1:]
acur = entry[1].replace(name, "").replace("/", "")
fullurl = ""
for e in thing[0][4][:-1]:
fullurl = fullurl+e+" > "
if acur in ["chr", "veh", "loc", "obj"]:
assetname = talk.text(acur)+": "+name
else:
assetname = entry[1]
# ASSINGING TEXT VALUES
taskname = thing[0][4][-1]
taskurl = fullurl
taskcur = assetname.replace("/set","")
# AND A TINY BUTTON TO ENTER WHAT EVER YOU ARE DOING
goto = "analytics"
if acur in ["chr", "veh", "loc","obj"]:
goto = "assets"
itemtype = "assets"
elif not acur:
itemtype = "files"
else:
goto = "script"
itemtype = "scenes"
def do():
win.url = goto
win.cur = entry[1]
win.current["asset_left_panel"] = "schedule"
UI_elements.roundrect(layer, win,
win.current["w"]/3*2+60,
5,
(win.current["w"]/3-65),
40,
10,
button=do)
break
else:
break
# Schedule
if taskname:
UI_elements.image(layer, win, "settings/themes/"\
+win.settings["Theme"]+"/icons/schedule.png",
win.current["w"]/3*2+60,
5,
40,
40)
UI_color.set(layer, win, "text_normal")
layer.set_font_size(20)
layer.move_to(win.current["w"]/3*2+120, 25)
layer.show_text(taskname)
layer.set_font_size(12)
layer.move_to(win.current["w"]/3*2+130+len(taskname)*12, 25)
layer.show_text(taskurl)
layer.set_font_size(12)
layer.move_to(win.current["w"]/3*2+120, 40)
layer.show_text(taskcur)
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Analytics", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
###### LEFT PANNEL #######
# New Scene
def do():
# Okay let's make the adding the scene possible.
# First we need to know what scenes are there. So we don't overwrite
# any existing scene.
scenename = "Scene"
count = 2
while scenename in win.story["scenes"]:
scenename = "Scene_"+str(count)
count = count + 1
# Now that we have an empty name. Let's add a scene.
win.story["scenes"][scenename] = {
"fraction":0.0, # Percentage
"position":[
win.current["mx"]-win.story["camera"][0]-50,
win.current["my"]-win.story["camera"][1]-30
],
"size":[100, 60],
"parent":"", # For when it's in a Frame (Event)
"shots":[[
"text_block",[["text", '']]
]]
}
# Auto select the new scene
win.story["selected"] = [["scene", scenename]]
win.current["tool"] = "grab"
# A hack I guess. I don't know what I'm doing. I'm trying to force
# the motion on click.
win.current["LMB"] = [win.current["mx"], win.current["my"], True]
# In studio/studio_gtk.py there is a command that recognizes the length
# of the LMB. And it's more then 2 it does some magic to make stuff move
# without pressing the actuall key. It's slightly too clever even for me
# so yeah.
UI_elements.roundrect(layer, win,
5,
105,
40,
40,
10,
do,
"scene_new",
talk.text("new_scene_tooltip")+"\n[N]",
url="story_editor")
# Shortcut
if 110 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
# Link Asset
def do():
def after(win, var):
print (var)
if var:
win.story["links"].append([
"asset", var, [
win.current["mx"]-win.story["camera"][0]-75,
win.current["my"]-win.story["camera"][1]-75
],
"" # Parent
])
# Now let's select and move the thing
win.story["selected"] = [["asset", len(win.story["links"])-1]]
win.current["tool"] = "grab"
win.current["LMB"] = [win.current["mx"], win.current["my"], True]
studio_dialogs.asset_select(win, "new_asset_story", after)
UI_elements.roundrect(layer, win,
5,
155,
40,
40,
10,
do,
"obj_link",
talk.text("link_asset_tooltip")+"\n[L]",
url="story_editor")
# Shortcut
if 108 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
# Link File
def do():
def after(win, var):
if var:
win.story["links"].append([
"file", var, [
win.current["mx"]-win.story["camera"][0]-75,
win.current["my"]-win.story["camera"][1]-75
],
"" # Parent
])
# Now let's select and move the thing
win.story["selected"] = [["file", len(win.story["links"])-1]]
win.current["tool"] = "grab"
win.current["LMB"] = [win.current["mx"], win.current["my"], True]
studio_dialogs.file_select(win, "new_file_story", after, force=True)
UI_elements.roundrect(layer, win,
5,
205,
40,
40,
10,
do,
"file_link",
talk.text("link_file_tooltip")+"\n[I]",
url="story_editor")
# Shortcut
if 105 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
# Marker
def do():
markername = "Marker"
count = 2
while markername in win.story["markers"]:
markername = "Marker_"+str(count)
count = count + 1
win.story["markers"][markername] = [
win.current["mx"]-win.story["camera"][0]+50,
win.current["my"]-win.story["camera"][1]-20,
"" # Parent
]
win.textactive = markername+"_marker"
win.text[markername+"_marker"] = {
"text" :markername, # Actuall text you are editing.
"cursor":[len(str(markername)),len(str(markername))], # Cursor
"insert":False, # Whether the insert mode is on
"scroll":"markername_scroll" # If multiline. The pointer for the scroll value.
}
win.story["selected"] = [["marker", markername]]
win.current["tool"] = "grab"
win.current["LMB"] = [win.current["mx"], win.current["my"], True]
UI_elements.roundrect(layer, win,
5,
255,
40,
40,
10,
do,
"pin",
talk.text("marker_tooltip")+"\n[M]",
url="story_editor")
# Shortcut
if 109 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
if win.story["selected"]:
# Event
def do():
eventname = "Event"
count = 2
while eventname in win.story["events"]:
eventname = "Event_"+str(count)
count = count + 1
win.story["events"][eventname] = {
"position":[0,0],
"size":[0,0]
}
# Even going to delete it self if there will be noone who parenting
# it.
for thing in win.story["selected"]:
if thing[0] == "scene":
win.story["scenes"][thing[1]]["parent"] = eventname
elif thing[0] in ["file", "asset"]:
win.story["links"][thing[1]][3] = eventname
elif thing[0] == "marker":
win.story["markers"][thing[1]][2] = eventname
UI_elements.roundrect(layer, win,
5,
305,
40,
40,
10,
do,
"event",
talk.text("event_tooltip")+"\n[E]",
url="story_editor")
# Shortcut
if 101 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
# Renders
def do():
def after(win, var):
pass
studio_dialogs.render(win, "current_renders", after)
UI_elements.roundrect(layer, win,
5,
405,
40,
40,
10,
do,
"render",
talk.text("render_lists_tooltip"),
url="story_editor")
# Let's draw on top of this button a little indicator of how many renders
# are currently setup.
if win.renders:
count = str(len(win.renders))
UI_color.set(layer, win, "node_background")
UI_elements.roundrect(layer, win,
30,
405,
len(count)*12+6,
25,
5)
layer.fill()
UI_color.set(layer, win, "text_normal")
layer.set_font_size(20)
layer.move_to(33,425)
layer.show_text(count)
# Edit Video
def do():
def after(win, var):
if var:
print(var)
oscalls.file_open(win, var)
studio_dialogs.vse(win, "VSEs", after)
UI_elements.roundrect(layer, win,
5,
455,
40,
40,
10,
do,
"vse",
talk.text("vse_tooltip"),
url="story_editor")
# Export to ODT
def do():
story.export_to_odt(win)
UI_elements.roundrect(layer, win,
5,
555,
40,
40,
10,
do,
"export",
talk.text("export_tooltip"),
url="story_editor")
# Bottom
# Multiuser
def do():
win.url = "multiuser"
UI_elements.roundrect(layer, win,
5,
win.current["h"]-95,
40,
40,
10,
do,
"multiuser",
talk.text("multiuser_tooltip"),
url="story_editor")
if win.multiuser["unread"]:
count = str(win.multiuser["unread"])
UI_color.set(layer, win, "node_background")
UI_elements.roundrect(layer, win,
30,
win.current["h"]-100,
len(count)*12+6,
25,
5)
layer.fill()
UI_color.set(layer, win, "text_normal")
layer.set_font_size(20)
layer.move_to(33,win.current["h"]-83)
layer.show_text(count)
# Settings
def do():
win.url = "settings_layer"
UI_elements.roundrect(layer, win,
5,
win.current["h"]-45,
40,
40,
10,
do,
"settings",
talk.text("Settings"),
url="story_editor")
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Left Panel", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
###### RIGHT PANNEL #######
def select_character(win, var):
if var:
win.url = "assets"
win.cur = var
win.current["tool"] = "selection"
# Characters
def do():
studio_dialogs.asset_select(win, "new_asset_story", select_character, force=True, cur="chr")
UI_elements.roundrect(layer, win,
win.current["w"]-45,
105,
40,
40,
10,
do,
"chr",
talk.text("chr")+"\n[Shift-C]",
url="story_editor")
# Shortcut
if 67 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
# Vehicles
def do():
studio_dialogs.asset_select(win, "new_asset_story", select_character, force=True, cur="veh")
UI_elements.roundrect(layer, win,
win.current["w"]-45,
155,
40,
40,
10,
do,
"veh",
talk.text("veh")+"\n[Shift-V]",
url="story_editor")
# Shortcut
if 86 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
# Locations
def do():
studio_dialogs.asset_select(win, "new_asset_story", select_character, force=True, cur="loc")
UI_elements.roundrect(layer, win,
win.current["w"]-45,
205,
40,
40,
10,
do,
"loc",
talk.text("loc")+"\n[Shift-L]",
url="story_editor")
# Shortcut
if 76 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
# Other (obj)
def do():
studio_dialogs.asset_select(win, "new_asset_story", select_character, force=True, cur="obj")
UI_elements.roundrect(layer, win,
win.current["w"]-45,
255,
40,
40,
10,
do,
"obj",
talk.text("obj")+"\n[Shift-O]",
url="story_editor")
# Shortcut
if 79 in win.current["keys"] and not win.textactive:
do()
win.current["keys"] = []
# Sounds / Music
def do():
os.system("xdg-open "+win.project+"/mus")
UI_elements.roundrect(layer, win,
win.current["w"]-45,
355,
40,
40,
10,
do,
"mus",
talk.text("mus"),
url="story_editor")
# Help
def do():
def after(win, var):
pass
studio_dialogs.help(win, "help", after, SEARCH=talk.text("documentation_story_editor"))
UI_elements.roundrect(layer, win,
win.current["w"]-45,
win.current["h"]-125,
40,
40,
10,
do,
"question",
url="story_editor")
# Folder
def do():
os.system("xdg-open "+win.project)
UI_elements.roundrect(layer, win,
win.current["w"]-45,
win.current["h"]-75,
40,
40,
10,
do,
"folder",
talk.text("project_folder"),
url="story_editor")
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Right Pannel", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
if win.url == "story_editor"\
and int(win.current["mx"]) in range(50, int(win.current["w"]-50)) \
and int(win.current["my"]) in range(50, int(win.current["h"]-30)):
# The cross cursor
win.current["cursor"] = win.cursors["cross"]
####### NODES #######
# Clipping so it wont draw beyon the frame
UI_elements.roundrect(layer, win,
50,
50,
win.current["w"] - 100,
win.current["h"] - 80,
30,
fill=False)
layer.clip()
# Background Image
if os.path.exists(win.project+"/set/banner.png"):
UI_elements.image(layer, win, win.project+"/set/banner.png",
50,
50,
win.current["w"] - 100,
win.current["h"] - 80,
cell="background")
elif os.path.exists(win.project+"/py_data/banner.png"):
UI_elements.image(layer, win, win.project+"/py_data/banner.png",
50,
50,
win.current["w"] - 100,
win.current["h"] - 80,
cell="background")
else:
UI_elements.image(layer, win, "icon.png",
50,
50,
win.current["w"] - 100,
win.current["h"] - 80,
cell="background")
UI_color.set(layer, win, "node_background")
layer.rectangle(0,0,win.current["w"], win.current["h"])
layer.fill()
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Background Image", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# You probably intersted where is the scroll function for this part. Well
# see there is a thing. It's easier to write one from screach here. Because
# you geassed it we are starting to draw story editor.
# Let's prepare the camera first.
# Animation
win.story["camera"][0] = UI_elements.animate("cameraX", win, 0, win.story["camera"][0])
win.story["camera"][1] = UI_elements.animate("cameraY", win, 0, win.story["camera"][1])
cx, cy = win.story["camera"]
if win.url == "story_editor":
if win.current["MMB"]:
win.story["camera"][0] += ( win.current["mx"]-win.previous["mx"])
win.story["camera"][1] += ( win.current["my"]-win.previous["my"])
win.story["camera"][0] -= win.current["scroll"][0]*50
win.story["camera"][1] -= win.current["scroll"][1]*50
if cx != win.story["camera"][0] or cy != win.story["camera"][1]:
UI_elements.animate("cameraX", win, win.story["camera"][0], force=True)
UI_elements.animate("cameraY", win, win.story["camera"][1], force=True)
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Camera position", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# EVENTS (Frames)
try:
for event in win.story["events"]:
# Loaction
sx, sy = win.story["events"][event]["position"]
# Scale
ssx, ssy = win.story["events"][event]["size"]
#Draw
studio_nodes.event_node(layer, win, sx, sy, ssx, ssy, name=event)
# Let's now check if the event even has anybody inside. It's a bit
# not the best way to implement it yet. Because I will need to look
# through all items. But we can make it simpler if we find that it has
# we can just break out of a thing.
found = False
for scene in win.story["scenes"]:
if event == win.story["scenes"][scene]["parent"]:
found = True
break
if not found:
for link in win.story["links"]:
if event == link[3]:
found = True
break
if not found:
for marker in win.story["markers"]:
if event == win.story["markers"][marker][2]:
found = True
break
# If nobody is inside. Delete the bastard.
if not found:
del win.story["events"][event]
except:
pass
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Events", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# SCENES
try:
for scene in win.story["scenes"]:
# Loaction
sx, sy = win.story["scenes"][scene]["position"]
sx = sx + cx
sy = sy + cy
# Scale
ssx, ssy = win.story["scenes"][scene]["size"]
#Fraction
sf = win.story["scenes"][scene]["fraction"]
#Draw
studio_nodes.scene_node(layer, win, sx, sy, ssx, ssy, name=scene, fraction=sf)
except:
pass
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Scenes", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# LINKS (Images, Stuff)
for num, link in enumerate(win.story["links"]):
linktype = link[0]
linkname = link[1]
lx = link[2][0] + cx
ly = link[2][1] + cy
# For the one inside the project. They should be always relative
# so even if the project is in a complitely different location
# on another machine. Where we have our Multiuser data. It should
# be able to load these.
if win.project in link[1]:
link[1] = link[1].replace(win.project, "")
studio_nodes.link_node(layer, win, lx, ly, name=linkname, num=num, linktype=linktype )
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Files / Assets", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# Let's put in the start and the end nodes. These are drawn on top of
# everything.
studio_nodes.start_node(layer, win, 60,60,100,40)
studio_nodes.end_node(layer, win, win.current["w"] - 160,
win.current["h"] - 80,
100,40)
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Start / End Nodes", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# MARKERS
try:
for marker in win.story["markers"]:
mx = win.story["markers"][marker][0] + cx
my = win.story["markers"][marker][1] + cy
studio_nodes.marker(layer, win, marker, mx, my)
except:
pass
# MARKERS
try:
for user in win.multiuser["users"]:
if user != win.multiuser["userid"]:
mx = 0-win.multiuser["users"][user]["camera"][0] +cx + win.current["w"]/2
my = 0-win.multiuser["users"][user]["camera"][1] +cy + win.current["h"]/2
studio_nodes.user(layer, win, win.multiuser["users"][user]["username"], mx, my, user)
except Exception as e:
print(e, "USER RENDERING")
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Markers", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# In case there is a selection bug
if not win.story["selected"] and win.current["tool"] != "connect":
win.current["tool"] = "selection"
# Selector visualization
if win.current["LMB"] and win.current["tool"] == "selection" and win.url == "story_editor":
# Draw selection box
UI_color.set(layer, win, "progress_background")
layer.rectangle(
win.current["mx"],
win.current["my"],
win.current["LMB"][0] - win.current["mx"],
win.current["LMB"][1] - win.current["my"]
)
layer.stroke()
# Now let's draw the cool AF multi selection zone thingy
# Draw selection box
if len(win.story["selected"]) > 1 and win.current["tool"] == "selection":
UI_color.set(layer, win, "progress_background")
layer.rectangle(
win.szone[0][0]-10,
win.szone[0][1]-10,
win.szone[1][0]+20,
win.szone[1][1]+20
)
layer.stroke()
# Now I want to make a tiny widget that will resize the stuff.
if win.story["selected"]:
if win.current["tool"] == "selection":
draw_circle = True
if len(win.story["selected"]) == 1:
if win.story["selected"][0][0] != "scene":
draw_circle = False
if draw_circle:
UI_color.set(layer, win, "node_badfile")
UI_elements.roundrect(layer, win,
win.szone[0][0]+win.szone[1][0],
win.szone[0][1]+win.szone[1][1],
0,
0,
10)
UI_color.set(layer, win, "progress_background")
UI_elements.roundrect(layer, win,
win.szone[0][0]+win.szone[1][0],
win.szone[0][1]+win.szone[1][1],
0,
0,
10,
fill=False)
layer.stroke()
elif win.current["tool"] == "scale":
UI_color.set(layer, win, "node_badfile")
UI_elements.roundrect(layer, win,
win.current["mx"]-10,
win.current["my"]-10,
0,
0,
10)
UI_color.set(layer, win, "progress_background")
UI_elements.roundrect(layer, win,
win.current["mx"]-10,
win.current["my"]-10,
0,
0,
10,
fill=False)
layer.stroke()
if int(win.current["mx"]) in range(int(win.szone[0][0]+win.szone[1][0]), int(win.szone[0][0]+win.szone[1][0]+20))\
and int(win.current["my"]) in range(int(win.szone[0][1]+win.szone[1][1]), int(win.szone[0][1]+win.szone[1][1]+20))\
and win.current["tool"] == "selection":
UI_color.set(layer, win, "text_normal")
UI_elements.roundrect(layer, win,
win.szone[0][0]+win.szone[1][0],
win.szone[0][1]+win.szone[1][1],
0,
0,
10,
fill=False)
layer.stroke()
win.current["cursor"] = win.cursors["arrow"]
if win.current["LMB"] and not win.previous["LMB"]:
win.current["tool"] = "scale"
if win.current["tool"] == "scale" and not win.current["LMB"]:
win.current["tool"] = "selection"
# Canceling seletion. I move it here so it would not interfire with the
# the rest of the program.
if win.current["LMB"] and win.current["tool"] == "selection" and win.url == "story_editor":
# Undo selection
if int(win.current["LMB"][0] - win.current["mx"]) in range(-10, 10)\
and int(win.current["LMB"][1] - win.current["my"])in range(-10, 10)\
and int(win.current["mx"]) in range(50, int(win.current["w"]-50)) \
and int(win.current["my"]) in range(50, int(win.current["h"]-30))\
and 65505 not in win.current["keys"]:
win.story["selected"] = []
win.textactive = ""
# Let's draw the line while connecting 2 scenes together.
if win.current["tool"] == "connect":
win.current["cursor"] = win.cursors["arrow"]
if not win.current["LMB"]:
win.current["tool"] = "selection"
fr = win.current["draw_dot"]
if type(fr) == list:
fr = fr[0]+":"+fr[1]
try:
UI_color.set(layer, win, "node_script")
layer.move_to(
win.out_dots[fr][0],
win.out_dots[fr][1]
)
layer.line_to(win.current["mx"], win.current["my"])
layer.stroke()
except:
pass
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Selection", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# The undo history is quite a new adition so the limit setting might
# not exists. So let's make it if so.
if "Undo_Limit" not in win.settings:
win.settings["Undo_Limit"] = 32
settings.write("Undo_Limit", 32)
if win.animations["cameraX"][1] == cx:
win.current["camera_arrived"] = True
else:
win.current["camera_arrived"] = False
# Save story. I'm going to do it the same way as in the old Blender-Organizer
if win.url == "story_editor":
savenow = False
if win.previous["LMB"] and not win.current["LMB"]:
savenow = True
elif win.previous["RMB"] and not win.current["RMB"]:
savenow = True
elif win.previous["MMB"] and not win.current["MMB"]:
savenow = True
elif win.previous["keys"] and not win.current["keys"]:
savenow = True
elif win.current["camera_arrived"] and not win.previous["camera_arrived"]:
savenow = True
if savenow:
win.current["cursor"] = win.cursors["watch"]
# Now let's run the history record.
story.undo_record(win)
story.save(win.project, win.story)
analytics.save(win.project, win.analytics)
# Need to reload the story to reload the fractions of the scenes.
win.story = story.load(win.project)
# Multiuser sycning
win.multiuser["request"] = "story"
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "File Saving", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
# To selected
if 65454 in win.current["keys"] and win.story["selected"] and not win.textactive:
nex = cx-win.szone[0][0] - win.szone[1][0]/2 + win.current["w"]/2
ney = cy-win.szone[0][1] - win.szone[1][1]/2 + win.current["h"]/2
UI_elements.animate("cameraX", win, win.story["camera"][0],nex, force=True)
UI_elements.animate("cameraY", win, win.story["camera"][1],ney, force=True)
# Undo
if 65507 in win.current["keys"] and 122 in win.current["keys"] and not win.textactive:
story.undo(win)
win.current["keys"] = []
# Redo
if 65507 in win.current["keys"] and 121 in win.current["keys"] and not win.textactive:
story.redo(win)
win.current["keys"] = []
# Grab
if 103 in win.current["keys"] and win.story["selected"] and not win.textactive:
win.current["tool"] = "grab"
win.current["LMB"] = [win.current["mx"], win.current["my"], True]
# Scale
if 115 in win.current["keys"] and win.story["selected"] and not win.textactive:
win.current["tool"] = "scale"
win.current["LMB"] = [win.current["mx"], win.current["my"], True]
# Deletion
if 65535 in win.current["keys"] and win.current["tool"] == "selection"\
and win.url == "story_editor" and win.story["selected"] and not win.textactive:
win.url = "story_deletion_dialog"
########### TIMES RECORDING FOR PERFONMANCE MEASURING #############
fif = datetime.datetime.now()
mil = fif - stf
perfStat.append([ "Short Cuts", mil.microseconds ])
stf = datetime.datetime.now()
###################################################################
############### PERFORMCE TESTING GROUND ##############
if win.current["testing"]:
h = win.current["h"]+200
w = win.current["w"]
UI_color.set(layer, win, "darker_parts")
UI_elements.roundrect(layer, win,100, h-(len(perfStat)*15)-30-300, 500,len(perfStat)*15+30, 10)
l = 0
s = 0
for i in perfStat:
if int(i[1]) > l:
l = int(i[1])
s = s + int(i[1])
for n, i in enumerate(perfStat):
#UI_color.set(layer, win, "progress_background")
#UI_elements.roundrect(layer, win, 110 + 270, h-(len(perfStat)*15)-20+10+15*n-300, 200,10, 5)
layer.set_source_rgb(1,1,1)
if int(i[1]) == l:
layer.set_source_rgb(1,0,0)
elif int(i[1]) < 1000:
layer.set_source_rgb(0,1,0)
layer.set_font_size(10)
layer.move_to( 110, h-(len(perfStat)*15)+15*n-300)
p = float(i[1]) / s *100
layer.show_text(str(i[0])+" - "+str(i[1])+" MCRS "+str(int(round(p)))+"%")
#UI_color.set(layer, win, "progress_active")
UI_elements.roundrect(layer, win, 110 + 270, h-(len(perfStat)*15)-20+10+15*n-300, int(round(p))*2,10, 5)
return surface