def get_compiler(cls):
from stylus import Stylus
compiler = Stylus(compress=cls.compress,
paths=cls.paths)
for i in cls.plugins:
compiler.use(i)
return compiler
def compile():
compiler = Stylus()
for fname in glob(fl + '/static/css/*.styl'):
print('compiling ' + fname)
styl = open(fname, 'r')
css = open(fname.replace('.styl', '.css'), 'w')
css.write(compiler.compile(styl.read()))
styl.close()
css.close()
def build_files(outdir):
"""Build the files!"""
# Make sure there is actually a configuration file
config_file_dir = os.path.join(cwd, "config.py")
if not os.path.exists(config_file_dir):
sys.exit(
"There dosen't seem to be a configuration file. Have you run the init command?"
)
else:
sys.path.insert(0, cwd)
try:
from config import website_name, website_description, website_language, home_page_list
except:
sys.exit(
"ERROR: Some of the crucial configuration values could not be found! Maybe your config.py is too old. Run 'blended init' to fix."
)
try:
from config import website_description_long, website_license, website_url, author_name, author_bio, plugins, minify_css, minify_js, custom_variables
except:
website_description_long = ""
website_license = ""
website_url = ""
author_name = ""
author_bio = ""
plugins = []
custom_variables = {}
minify_css = False
minify_js = False
print(
"WARNING: Some of the optional configuration values could not be found! Maybe your config.py is too old. Run 'blended init' to fix.\n"
)
# Create the build folder
build_dir = os.path.join(cwd, outdir)
if "." not in outdir and ".." not in outdir and "..." not in outdir and "...." not in outdir and "....." not in outdir:
replace_folder(build_dir)
# Make sure there is actually a header template file
header_file_dir = os.path.join(cwd, "templates", "header.html")
if not os.path.exists(header_file_dir):
sys.exit(
"There dosen't seem to be a header template file. You need one to generate."
)
# Make sure there is actually a footer template file
footer_file_dir = os.path.join(cwd, "templates", "footer.html")
if not os.path.exists(footer_file_dir):
sys.exit(
"There dosen't seem to be a footer template file. You need one to generate."
)
# Open the header and footer files for reading
header_file = open(header_file_dir, "r")
footer_file = open(footer_file_dir, "r")
# Create the HTML page listing
page_list_item_file = os.path.join(cwd, "templates", "page_list_item.html")
if not os.path.exists(page_list_item_file):
page_list = '<ul class="page-list">\n'
for root, dirs, files in os.walk(os.path.join(cwd, "content")):
for filename in files:
top = os.path.dirname(os.path.join(root, filename))
top2 = top.replace(os.path.join(cwd, "content"), "", 1)
if platform != "win32":
subfolder = top2.replace("/", "", 1)
else:
subfolder = top2.replace("\\", "", 1)
if subfolder == "":
subfolder_link = ""
else:
subfolder_link = subfolder + "/"
file_modified = time.ctime(
os.path.getmtime(os.path.join(root, filename)))
newFilename = get_html_filename(filename)
newFilename2 = get_html_clear_filename(filename)
page_list = page_list + '<li class="page-list-item"><a href="' + subfolder_link + newFilename + \
'">' + newFilename2 + '</a><span class="page-list-item-time"> - ' + \
str(file_modified) + '</span></li>\n'
page_list = page_list + '</ul>'
else:
with open(page_list_item_file, 'r') as f:
page_list_item = f.read()
page_list = ""
for root, dirs, files in os.walk(os.path.join(cwd, "content")):
dirs[:] = [d for d in dirs if "_" not in d]
for filename in files:
p_content = convert_text(os.path.join(root, filename))
top = os.path.dirname(os.path.join(root, filename))
top2 = top.replace(os.path.join(cwd, "content"), "", 1)
if platform != "win32":
subfolder = top2.replace("/", "", 1)
else:
subfolder = top2.replace("\\", "", 1)
if subfolder == "":
subfolder_link = ""
else:
subfolder_link = subfolder + "/"
file_modified = time.ctime(
os.path.getmtime(os.path.join(root, filename)))
file_modified_day = str(
datetime.strptime(file_modified,
"%a %b %d %H:%M:%S %Y"))[8:10]
file_modified_year = str(
datetime.strptime(file_modified,
"%a %b %d %H:%M:%S %Y"))[:4]
file_modified_month = str(
datetime.strptime(file_modified,
"%a %b %d %H:%M:%S %Y"))[5:7]
month_name = calendar.month_name[int(file_modified_month)]
newFilename = get_html_filename(filename)
newFilename2 = get_html_clear_filename(filename)
page_list = page_list + page_list_item.replace(
"{path}", subfolder_link + newFilename).replace(
"{name}", newFilename2).replace(
"{date}", str(file_modified)).replace(
"{content}", p_content).replace(
"{content_short}", p_content[:250] + "..."
).replace("{day}", file_modified_day).replace(
"{month}", file_modified_month).replace(
"{month_name}", month_name).replace(
"{year}", file_modified_year)
if home_page_list == "yes" or home_page_list:
# Open the home page file (index.html) for writing
home_working_file = open(os.path.join(cwd, outdir, "index.html"), "w")
home_working_file.write(header_file.read())
# Make sure there is actually a home page template file
home_templ_dir = os.path.join(cwd, "templates", "home_page.html")
if os.path.exists(home_templ_dir):
home_templ_file = open(home_templ_dir, "r")
home_working_file.write(home_templ_file.read())
else:
print(
"\nNo home page template file found. Writing page list to index.html"
)
home_working_file.write(page_list)
home_working_file.write(footer_file.read())
home_working_file.close()
for root, dirs, files in os.walk(os.path.join(cwd, "content")):
dirs[:] = [d for d in dirs if "_" not in d]
for filename in files:
if not filename.startswith("_"):
header_file = open(header_file_dir, "r")
footer_file = open(footer_file_dir, "r")
newFilename = get_html_filename(filename)
top = os.path.dirname(os.path.join(root, filename))
top2 = top.replace(os.path.join(cwd, "content"), "", 1)
if platform != "win32":
subfolder = top2.replace("/", "", 1)
else:
subfolder = top2.replace("\\", "", 1)
if subfolder == "":
currents_working_file = open(
os.path.join(cwd, outdir, newFilename), "w")
else:
create_folder(os.path.join(cwd, outdir, subfolder))
currents_working_file = open(
os.path.join(cwd, outdir, subfolder, newFilename), "w")
# Write the header
currents_working_file.write(header_file.read())
text_cont1 = convert_text(os.path.join(root, filename))
if "+++++" in text_cont1.splitlines()[1]:
page_template_file = text_cont1.splitlines()[0]
text_cont1 = text_cont1.replace(text_cont1.splitlines()[0],
"")
text_cont1 = text_cont1.replace(text_cont1.splitlines()[1],
"")
else:
page_template_file = "content_page"
# Write the text content into the content template and onto the
# build file
content_templ_dir = os.path.join(cwd, "templates",
page_template_file + ".html")
if os.path.exists(content_templ_dir):
content_templ_file = open(content_templ_dir, "r")
content_templ_file1 = content_templ_file.read()
content_templ_file2 = content_templ_file1.replace(
"{page_content}", text_cont1)
currents_working_file.write(content_templ_file2)
else:
currents_working_file.write(text_cont1)
# Write the footer to the build file
currents_working_file.write("\n" + footer_file.read())
# Close the build file
currents_working_file.close()
# Find all the nav(something) templates in the `templates` folder and
# Read their content to the dict
navs = {}
for file in os.listdir(os.path.join(cwd, "templates")):
if "nav" in file:
nav_cont = open(os.path.join(cwd, "templates", file), "r")
navs[file.replace(".html", "")] = nav_cont.read()
nav_cont.close()
forbidden_dirs = set(["assets", "templates"])
blended_version_message = "Built with Blended v" + \
str(app_version)
build_date = str(datetime.now().date())
build_time = str(datetime.now().time())
build_datetime = str(datetime.now())
# Replace global variables such as site name and language
for root, dirs, files in os.walk(os.path.join(cwd, outdir)):
dirs[:] = [d for d in dirs if d not in forbidden_dirs]
for filename in files:
if filename != "config.pyc" and filename != "config.py":
newFilename = get_html_clear_filename(filename)
page_file = filename.replace(".html", "")
page_folder = os.path.basename(
os.path.dirname(os.path.join(root, filename))).replace(
"-", "").replace("_", "").title()
page_folder_orig = os.path.basename(
os.path.dirname(os.path.join(root, filename)))
top = os.path.dirname(os.path.join(root, filename))
top2 = top.replace(os.path.join(cwd, outdir), "", 1)
if platform != "win32":
subfolder = top2.replace("/", "", 1)
else:
subfolder = top2.replace("\\", "", 1)
if subfolder == "":
subfolder_folder = os.path.join(cwd, outdir, filename)
else:
subfolder_folder = os.path.join(cwd, outdir, subfolder,
filename)
file_modified = time.ctime(
os.path.getmtime(os.path.join(root, filename)))
file_modified_day = str(
datetime.strptime(file_modified,
"%a %b %d %H:%M:%S %Y"))[8:10]
file_modified_year = str(
datetime.strptime(file_modified,
"%a %b %d %H:%M:%S %Y"))[:4]
file_modified_month = str(
datetime.strptime(file_modified,
"%a %b %d %H:%M:%S %Y"))[5:7]
month_name = calendar.month_name[int(file_modified_month)]
# The Loop!
for line in fileinput.input(subfolder_folder, inplace=1):
for var in custom_variables:
line = line.replace("{" + var + "}",
custom_variables[var])
if len(plugins) != 0:
for i in range(len(plugins)):
if sys.version_info[0] < 2:
main = importlib.import_module(plugins[i])
elif sys.version_info[0] < 3:
main = __import__(plugins[i])
content = main.main()
line = line.replace("{" + plugins[i] + "}",
content)
if "{nav" in line:
navname = line.split("{")[1].split("}")[0]
line = line.replace(
"{" + navname + "}",
navs[(line.split("{"))[1].split("}")[0]])
line = line.replace("{website_description}",
website_description)
line = line.replace("{website_description_long}",
website_description_long)
line = line.replace("{website_license}", website_license)
line = line.replace("{website_language}", website_language)
line = line.replace("{website_url}", website_url)
line = line.replace("{author_name}", author_name)
line = line.replace("{author_bio}", author_bio)
line = line.replace("{random_number}",
str(randint(0, 100000000)))
line = line.replace("{build_date}", build_date)
line = line.replace("{build_time}", build_time)
line = line.replace("{build_datetime}", build_datetime)
line = line.replace("{page_list}", page_list)
line = line.replace("{page_name}", newFilename)
line = line.replace("{page_filename}", page_file)
line = line.replace("{page_file}", filename)
line = line.replace("{" + filename + "_active}", "active")
if page_folder != outdir.title():
line = line.replace("{page_folder}", page_folder)
else:
line = line.replace("{page_folder}", "")
if page_folder_orig != outdir:
line = line.replace("{page_folder_orig}",
page_folder_orig)
else:
line = line.replace("{page_folder_orig}", "")
line = line.replace("{page_date}", str(file_modified))
line = line.replace("{page_day}", str(file_modified_day))
line = line.replace("{page_year}", str(file_modified_year))
line = line.replace("{page_month}",
str(file_modified_month))
line = line.replace("{page_month_name}", str(month_name))
line = line.replace("{blended_version}", str(app_version))
line = line.replace("{blended_version_message}",
blended_version_message)
line = line.replace("{website_name}", website_name)
top = os.path.join(cwd, outdir)
startinglevel = top.count(os.sep)
relative_path = ""
level = root.count(os.sep) - startinglevel
for i in range(level):
relative_path = relative_path + "../"
line = line.replace("{relative_root}", relative_path)
print(line.rstrip('\n'))
fileinput.close()
# Copy the asset folder to the build folder
if os.path.exists(os.path.join(cwd, "templates", "assets")):
if os.path.exists(os.path.join(cwd, outdir, "assets")):
shutil.rmtree(os.path.join(cwd, outdir, "assets"))
shutil.copytree(os.path.join(cwd, "templates", "assets"),
os.path.join(cwd, outdir, "assets"))
for root, dirs, files in os.walk(os.path.join(cwd, outdir, "assets")):
for file in files:
if not file.startswith("_"):
if (file.endswith(".sass")) or (file.endswith(".scss")):
sass_text = open(os.path.join(root, file)).read()
text_file = open(os.path.join(root, file[:-4] + "css"),
"w")
if sass_text != "":
text_file.write(sass.compile(string=sass_text))
else:
print(file + " is empty! Not compiling Sass.")
text_file.close()
if file.endswith(".less"):
less_text = open(os.path.join(root, file)).read()
text_file = open(os.path.join(root, file[:-4] + "css"),
"w")
if less_text != "":
text_file.write(lesscpy.compile(StringIO(less_text)))
else:
print(file + " is empty! Not compiling Less.")
text_file.close()
if file.endswith(".styl"):
try:
styl_text = open(os.path.join(root, file)).read()
text_file = open(os.path.join(root, file[:-4] + "css"),
"w")
if styl_text != "":
text_file.write(Stylus().compile(styl_text))
else:
print(file + " is empty! Not compiling Styl.")
text_file.close()
except:
print(
"Not able to build with Stylus! Is it installed?")
try:
subprocess.call["npm", "install", "-g", "stylus"]
except:
print("NPM (NodeJS) not working. Is it installed?")
if file.endswith(".coffee"):
coffee_text = open(os.path.join(root, file)).read()
text_file = open(os.path.join(root, file[:-6] + "js"), "w")
if coffee_text != "":
text_file.write(coffeescript.compile(coffee_text))
else:
print(file + " is empty! Not compiling CoffeeScript.")
text_file.close()
if minify_css:
if file.endswith(".css"):
css_text = open(os.path.join(root, file)).read()
text_file = open(os.path.join(root, file), "w")
if css_text != "":
text_file.write(cssmin(css_text))
text_file.close()
if minify_js:
if file.endswith(".js"):
js_text = open(os.path.join(root, file)).read()
text_file = open(os.path.join(root, file), "w")
if js_text != "":
text_file.write(jsmin(js_text))
text_file.close()
from camera import Camera, CAMERAS, decimations
from geometry import quantize_location
from graphics import plot_stylus_camera, plot_corners, plot_hotspots, update_display
from parameters import *
from UI import *
from smoothing import Smoothing
import pygame
from pygame.locals import *
#############################################################
camera = CAMERAS[which_camera]
decimation = decimations[which_camera] #decimation factor for showing image
camera_object = Camera(camera)
marker_object = Markers()
stylus_object = Stylus(which_stylus, stylus_length, camera_object.mtx, camera_object.dist)
print('Stylus:', which_stylus)
smoothing_object = Smoothing()
wb, sheet, board_parameters, hotspots, labels, labels_secondary = load_object(object_path+object_fname)
sound_object = Sounds(object_path, labels, labels_secondary)
cap = cv2.VideoCapture(int_or_ext)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT,camera_object.h) #set camera image height
cap.set(cv2.CAP_PROP_FRAME_WIDTH,camera_object.w) #set camera image width
cap.set(cv2.CAP_PROP_FOCUS,0) #set focus #5 often good for smaller objects and nearer camera
print('Image height, width:', camera_object.h, camera_object.w)
cnt = 0
timestamp0, next_scheduled_ambient_sound = time.time(), 0.
pose_known = False
def stylus_to_css(source):
compiler = Stylus(plugins={'nib':{}})
return as_unicode('<style>{css}</style>').format(css=compiler.compile(source).strip())
def get_stylus_compiler():
context = _app_ctx_stack.top
compiler = getattr(context, "prat_stylus_compiler", None)
if compiler is None:
compiler = context.prat_stylus_compiler = Stylus(plugins={ "nib": {} })
return compiler
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from stylus import Stylus
import threading
import sys
import os
import re
import fnmatch
compiler = Stylus()
def compileFile(filename):
if os.path.isfile(filename) and fnmatch.fnmatch(filename, '*.styl'):
stylusFile = open(filename, 'r')
content = stylusFile.read()
stylusFile.close()
result = compiler.compile(content)
resultPath = filename[0:-4] + 'css'
cssFile = open(resultPath, 'w')
cssFile.write(result)
cssFile.close()
def compileDir(path):
''' convert all the sylus file one time in the starting '''
matches = []
for root, dirnames, filenames in os.walk(path):
for filename in fnmatch.filter(filenames, '*.styl'):
matches.append(os.path.join(root, filename))
def __init__(self, parent=None):
super(WacomGui, self).__init__(parent)
self.setupUi(self)
self.toggle = False
self.load = False
self.cwd = os.path.dirname(os.path.abspath(__file__))
if self.cwd == '/usr/local/bin':
self.cwd = '/usr/local/wacom-gui'
self.setFocusPolicy(Qt.NoFocus)
# button instances
self.tabletButtons = ButtonGroup()
self.toolButtons = ButtonGroup()
self.configButtons = ButtonGroup()
# button layouts
self.tabletLayout = ButtonLayout()
self.toolLayout = ButtonLayout()
self.configLayout = ButtonLayout()
self.tabletScroll.setWidget(self.tabletLayout.frame)
self.toolScroll.setWidget(self.toolLayout.frame)
self.configScroll.setWidget(self.configLayout.frame)
# config files
self.configs = {}
# hold current device info
self.dev = None
self.dev_id = None
self.config = None
# load widgets
self.pad = Pad()
self.pad.hide()
self.stylus = Stylus()
self.stylus.hide()
self.touch = Touch()
self.touch.hide()
# ui icon
self.tabletRefresh.setIcon(QIcon(os.path.join(self.cwd, os.path.join(self.cwd, 'icons/ui/refresh.png'))))
# get connected tablet info
self.tablet_data = Tablets()
# attach function to refresh tablets
self.tabletRefresh.clicked.connect(self.refreshTablets)
# add buttons for connected tablets
self.initTabletButtons()
# generate tool buttons
self.initToolButtons()
# add/remove button functions
self.addConfig.setEnabled(True)
self.addConfig.clicked.connect(self.newConfig)
self.removeConfig.clicked.connect(self.verifyConfigRemove)
# about/help menu
self.aboutButton.clicked.connect(About.display)
# refresh tablet list, set tools, configs
self.refreshTablets()
self.controlBox.setContentsMargins(0, 0, 0, 0)
# add control widgets to control box
hbox = QHBoxLayout()
hbox.setAlignment(Qt.AlignHCenter)
hbox.addWidget(self.pad)
hbox.addWidget(self.stylus)
hbox.addWidget(self.touch)
self.controlBox.setLayout(hbox)
# save config button
self.saveConfig.clicked.connect(self.updateConfigs)
# configure device reset button
self.deviceDefaults.clicked.connect(self.deviceReset)
# load first tool found
self.toolSelect(self.toolButtons.btn_grp.checkedId())
# init button functions
self.tabletButtons.btn_grp.buttonClicked['int'].connect(self.tabletSelect)
self.toolButtons.btn_grp.buttonClicked['int'].connect(self.toolSelect)
self.configButtons.btn_grp.buttonClicked['int'].connect(self.configSelect)
class WacomGui(QMainWindow, wacom_menu.Ui_MainWindow):
buttonClicked = pyqtSignal(int)
def __init__(self, parent=None):
super(WacomGui, self).__init__(parent)
self.setupUi(self)
self.toggle = False
self.load = False
self.cwd = os.path.dirname(os.path.abspath(__file__))
if self.cwd == '/usr/local/bin':
self.cwd = '/usr/local/wacom-gui'
self.setFocusPolicy(Qt.NoFocus)
# button instances
self.tabletButtons = ButtonGroup()
self.toolButtons = ButtonGroup()
self.configButtons = ButtonGroup()
# button layouts
self.tabletLayout = ButtonLayout()
self.toolLayout = ButtonLayout()
self.configLayout = ButtonLayout()
self.tabletScroll.setWidget(self.tabletLayout.frame)
self.toolScroll.setWidget(self.toolLayout.frame)
self.configScroll.setWidget(self.configLayout.frame)
# config files
self.configs = {}
# hold current device info
self.dev = None
self.dev_id = None
self.config = None
# load widgets
self.pad = Pad()
self.pad.hide()
self.stylus = Stylus()
self.stylus.hide()
self.touch = Touch()
self.touch.hide()
# ui icon
self.tabletRefresh.setIcon(QIcon(os.path.join(self.cwd, os.path.join(self.cwd, 'icons/ui/refresh.png'))))
# get connected tablet info
self.tablet_data = Tablets()
# attach function to refresh tablets
self.tabletRefresh.clicked.connect(self.refreshTablets)
# add buttons for connected tablets
self.initTabletButtons()
# generate tool buttons
self.initToolButtons()
# add/remove button functions
self.addConfig.setEnabled(True)
self.addConfig.clicked.connect(self.newConfig)
self.removeConfig.clicked.connect(self.verifyConfigRemove)
# about/help menu
self.aboutButton.clicked.connect(About.display)
# refresh tablet list, set tools, configs
self.refreshTablets()
self.controlBox.setContentsMargins(0, 0, 0, 0)
# add control widgets to control box
hbox = QHBoxLayout()
hbox.setAlignment(Qt.AlignHCenter)
hbox.addWidget(self.pad)
hbox.addWidget(self.stylus)
hbox.addWidget(self.touch)
self.controlBox.setLayout(hbox)
# save config button
self.saveConfig.clicked.connect(self.updateConfigs)
# configure device reset button
self.deviceDefaults.clicked.connect(self.deviceReset)
# load first tool found
self.toolSelect(self.toolButtons.btn_grp.checkedId())
# init button functions
self.tabletButtons.btn_grp.buttonClicked['int'].connect(self.tabletSelect)
self.toolButtons.btn_grp.buttonClicked['int'].connect(self.toolSelect)
self.configButtons.btn_grp.buttonClicked['int'].connect(self.configSelect)
def initTabletButtons(self):
for dev, data in self.tablet_data.tablets.items():
for dev_id, tablet in enumerate(data):
icon = os.path.join(self.cwd, "icons/devices/%spng" % tablet['svg'][:-3])
if not os.path.isfile(os.path.join(os.getcwd(), icon)):
icon = os.path.join(self.cwd, 'icons/devices/generic.png')
self.tabletLayout.addButton(self.tabletButtons.addButton(tablet['cname'], tablet['pad']['id'],
str(dev), dev_id, icon))
def refreshTablets(self):
self.tablet_data.get_connected_tablets()
# clear current tablets from layout
self.tabletLayout.removeButtons()
self.tabletButtons.removeButton()
self.initTabletButtons()
if self.tabletButtons.buttons.items().__len__() == 0:
self.toolButtons.hideButtons()
else:
self.tabletSelect(0)
def initToolButtons(self):
# Functions/Stylus/Touch/Cursor
self.toolLayout.addButton(self.toolButtons.addButton("Functions", 0, 0, 0, os.path.join(self.cwd, 'icons/ui/functions.png'), 48, True))
self.toolLayout.addButton(self.toolButtons.addButton("Stylus", 0, 0, 0, os.path.join(self.cwd, 'icons/ui/stylus.png'), 48, True))
self.toolLayout.addButton(self.toolButtons.addButton("Touch", 0, 0, 0, os.path.join(self.cwd, 'icons/ui/touch.png'), 48, True))
self.toolLayout.addButton(self.toolButtons.addButton("Mouse", 0, 0, 0, os.path.join(self.cwd, 'icons/ui/mouse.png'), 48, True))
def setToolsAvail(self, idx):
self.dev = self.tabletButtons.buttons[(idx, 1)]
self.dev_id = self.tabletButtons.buttons[(idx, 3)]
if 'pad' in self.tablet_data.tablets[self.dev][self.dev_id].keys():
self.toolButtons.buttons[(0, 0)].setVisible(True)
self.toolButtons.buttons[(0, 1)] = self.dev
self.toolButtons.buttons[(0, 2)] = self.tablet_data.tablets[self.dev][self.dev_id]['pad']['id']
self.toolButtons.buttons[(0, 3)] = self.dev_id
else:
self.toolButtons.buttons[(0, 0)].setVisible(False)
self.toolButtons.buttons[(0, 1)] = 0
self.toolButtons.buttons[(0, 2)] = 0
self.toolButtons.buttons[(0, 3)] = 0
if 'stylus' in self.tablet_data.tablets[self.dev][self.dev_id].keys():
self.toolButtons.buttons[(1, 0)].setVisible(True)
self.toolButtons.buttons[(1, 1)] = self.dev
self.toolButtons.buttons[(1, 2)] = [self.tablet_data.tablets[self.dev][self.dev_id]['stylus']['id'],
self.tablet_data.tablets[self.dev][self.dev_id]['eraser']['id']]
self.toolButtons.buttons[(1, 3)] = self.dev_id
else:
self.toolButtons.buttons[(1, 0)].setVisible(False)
self.toolButtons.buttons[(1, 1)] = 0
self.toolButtons.buttons[(1, 2)] = 0
self.toolButtons.buttons[(1, 3)] = 0
if 'touch' in self.tablet_data.tablets[self.dev][self.dev_id].keys():
self.toolButtons.buttons[(2, 0)].setVisible(True)
self.toolButtons.buttons[(2, 1)] = self.dev
self.toolButtons.buttons[(2, 2)] = self.tablet_data.tablets[self.dev][self.dev_id]['touch']['id']
self.toolButtons.buttons[(2, 3)] = self.dev_id
else:
self.toolButtons.buttons[(2, 0)].setVisible(False)
self.toolButtons.buttons[(2, 1)] = 0
self.toolButtons.buttons[(2, 2)] = 0
self.toolButtons.buttons[(2, 3)] = 0
if 'cursor' in self.tablet_data.tablets[self.dev][self.dev_id].keys():
self.toolButtons.buttons[(3, 0)].setVisible(True)
self.toolButtons.buttons[(3, 1)] = self.dev
self.toolButtons.buttons[(3, 2)] = self.tablet_data.tablets[self.dev][self.dev_id]['cursor']['id']
self.toolButtons.buttons[(3, 3)] = self.dev_id
else:
self.toolButtons.buttons[(3, 0)].setVisible(False)
self.toolButtons.buttons[(3, 1)] = 0
self.toolButtons.buttons[(3, 2)] = 0
self.toolButtons.buttons[(3, 3)] = 0
def deviceReset(self):
self.pad.set_default()
self.stylus.resetPen()
self.stylus.resetEraser()
self.stylus.mapping.resetMapping()
self.touch.reset()
# TODO: add other resets
def emptyConfig(self, dev, dev_id):
config = {}
for input in self.tablet_data.tablets[dev][dev_id].keys():
if input in ['pad', 'stylus', 'eraser', 'touch', 'cursor']:
config[input] = {}
if input in ['pad', 'stylus', 'eraser']:
config[input]['buttons'] = {}
if input == 'pad':
buttons = self.tablet_data.tablets[dev][dev_id][input]['buttons']
for button in buttons.keys():
config['pad']['buttons'][button] = 'Default'
return config
def verifyConfigRemove(self):
reply = QMessageBox.question(self, 'Remove Config',
"Delete \"%s\" config file?" % self.config,
QMessageBox.Yes, QMessageBox.No)
if reply == QMessageBox.Yes:
home = "%s/.wacom-gui" % expanduser("~")
conf_path = os.path.join(home, "%s/%s.json" % (self.dev, self.config))
# delete file
try:
os.remove(conf_path)
except Exception as e:
print e
del self.configs[self.dev][self.config]
self.getConfigs(0)
def newConfig(self):
config = AddConfig.add_config(self.configs[self.dev].keys())
if config is not None:
# empty config
self.configs[self.dev][config] = self.emptyConfig(self.dev, self.dev_id)
# add button
self.configLayout.addButton(
self.configButtons.addButton(config, 0, 0, 0, os.path.join(self.cwd, 'icons/ui/config.png'), 48))
self.config = config
self.loadConfig(self.dev, self.dev_id, self.config)
for idx, button in enumerate(self.configButtons.btn_grp.buttons()):
if button.text() == self.config:
self.configButtons.btn_grp.buttons()[idx].setChecked(True)
self.tablet_data.tablets[self.dev][self.dev_id]['config'] = self.config
self.removeConfig.setEnabled(True)
def getConfigs(self, idx):
self.configLayout.removeButtons()
self.configButtons.removeButton()
dev = self.tabletButtons.buttons[(idx, 1)]
dev_id = self.tabletButtons.buttons[(idx, 3)]
home = "%s/.wacom-gui" % expanduser("~")
conf_path = os.path.join(home, dev)
self.tablet_data.tablets[dev][dev_id]['conf_path'] = os.path.join(home, dev)
if dev not in self.configs.keys():
self.configs[dev] = {}
if os.path.exists(conf_path):
# get configs in path
for config in os.listdir(conf_path):
if os.path.isfile(os.path.join(conf_path, config)) and config.endswith(".json"):
with open(os.path.join(conf_path, config), 'r') as f:
self.configs[dev][os.path.splitext(config)[0]] = json.load(f)
# TODO: allow user to sent alternate config to load by default
# load default config, if it exists
if 'default' not in self.configs[dev].keys():
self.configs[dev]['default'] = self.emptyConfig(dev, dev_id)
# get default config to load for given device, ie last selected config
self.config = 'default'
if os.path.exists("%s/device_default" % conf_path):
with open("%s/device_default" % conf_path, 'r') as f:
device = json.load(f)
# config file exists, use it
if str(dev_id) in device.keys() and device[str(dev_id)]['config'] in self.configs[dev].keys():
self.config = device[str(dev_id)]['config']
# set defaults in tablet_data, if it's detected
for idx in device.keys():
try:
self.tablet_data.tablets[self.dev][int(idx)]['config'] = device[idx]['config']
except Exception as e:
pass
self.configLayout.addButton(
self.configButtons.addButton("default", 0, 0, 0, os.path.join(self.cwd, 'icons/ui/config.png'), 48))
for config in sorted(self.configs[dev].keys()):
if config != 'default':
self.configLayout.addButton(
self.configButtons.addButton(config, 0, 0, 0, os.path.join(self.cwd, 'icons/ui/config.png'), 48))
# we are loading default config for now...
if self.config == 'default':
self.removeConfig.setEnabled(False)
else:
self.removeConfig.setEnabled(True)
self.loadConfig(dev, dev_id, self.config)
for idx, button in enumerate(self.configButtons.btn_grp.buttons()):
if button.text() == self.config:
self.configButtons.btn_grp.buttons()[idx].setChecked(True)
self.tablet_data.tablets[dev][dev_id]['config'] = self.config
else:
os.mkdir(self.tablet_data.tablets[dev][dev_id]['conf_path'])
self.configLayout.addButton(
self.configButtons.addButton("default", 0, 0, 0, os.path.join(self.cwd, 'icons/ui/config.png'), 48))
def loadConfig(self, dev, dev_id, config):
# TODO: load cursor configs
# load pad buttons
self.config = config
self.tablet_data.tablets[dev][dev_id]['config'] = self.config
if not self.toolButtons.buttons[(0, 0)].isHidden():
self.pad.init_keys(self.tablet_data.tablets[dev][dev_id]['pad']['id'],
self.tablet_data.tablets[dev][dev_id]['svg'],
self.tablet_data.tablets[dev][dev_id]['pad']['buttons'],
self.configs[dev][config]['pad']['buttons'])
if not self.toolButtons.buttons[(1, 0)].isHidden():
self.stylus.init_pen(self.tablet_data.tablets[dev][dev_id]['stylus']['id'],
self.configs[dev][config]['stylus'])
self.stylus.init_eraser(self.tablet_data.tablets[dev][dev_id]['eraser']['id'],
self.configs[dev][config]['eraser'])
if self.tablet_data.tablets[dev][dev_id]['stylus']['rotate'] == False:
# turn off rotate, if device doesn't support it
if 'mapping' in self.configs[dev][config]['stylus']:
self.configs[dev][config]['stylus']['mapping']['rotate'] = 'False'
else:
self.configs[dev][config]['stylus']['mapping'] = {'rotate': 'False'}
self.stylus.mapping.initUI(self.tablet_data.tablets[dev][dev_id]['stylus']['id'],
self.tablet_data.tablets[dev][dev_id]['eraser']['id'],
self.configs[dev][config]['stylus'])
if not self.toolButtons.buttons[(2, 0)].isHidden():
self.touch.init(self.tablet_data.tablets[dev][dev_id]['touch']['id'],
self.configs[dev][config]['touch'])
def tabletSelect(self, idx):
self.updateConfigs()
self.setToolsAvail(idx)
self.getConfigs(idx)
# set first available tool as selected
if not self.toolButtons.buttons[(0, 0)].isHidden():
self.toolButtons.buttons[(0, 0)].setChecked(True)
elif not self.toolButtons.buttons[(1, 0)].isHidden():
self.toolButtons.buttons[(1, 0)].setChecked(True)
elif not self.toolButtons.buttons[(2, 0)].isHidden():
self.toolButtons.buttons[(2, 0)].setChecked(True)
elif not self.toolButtons.buttons[(3, 0)].isHidden():
self.toolButtons.buttons[(3, 0)].setChecked(True)
def toolSelect(self, idx):
if idx == 0 and not self.toolButtons.buttons[(idx, 0)].isHidden():
# remove previous layout
self.pad.show()
self.stylus.hide()
self.touch.hide()
# stylus menu
elif idx == 1 and not self.toolButtons.buttons[(idx, 0)].isHidden():
# remove previous layout
self.pad.hide()
self.stylus.show()
self.touch.hide()
# touch menu
elif idx == 2 and not self.toolButtons.buttons[(idx, 0)].isHidden():
# remove previous layout
self.pad.hide()
self.stylus.hide()
self.touch.show()
# cursor menu
elif idx == 3 and not self.toolButtons.buttons[(idx, 0)].isHidden():
# remove previous layout
self.pad.hide()
self.stylus.hide()
self.touch.hide()
def configSelect(self, idx):
config = str(self.configButtons.buttons[(idx, 0)].text())
self.loadConfig(self.dev, self.dev_id, config)
if config == 'default':
self.removeConfig.setEnabled(False)
else:
self.removeConfig.setEnabled(True)
def deleteItemsOfLayout(self, layout):
if layout is not None:
while layout.count():
item = layout.takeAt(0)
widget = item.widget()
if widget is not None:
widget.setParent(None)
else:
self.deleteItemsOfLayout(item.layout())
def boxdelete(self, box):
for i in range(self.keys.count()):
layout_item = self.keys.itemAt(i)
if layout_item.layout() == box:
self.deleteItemsOfLayout(layout_item.layout())
self.vlayout.removeItem(layout_item)
break
def updateConfigs(self):
write = False
if not self.toolButtons.buttons[(0, 0)].isHidden():
pad = self.pad.get_config()
if pad != self.configs[self.dev][self.config]['pad']['buttons']:
write = True
self.configs[self.dev][self.config]['pad']['buttons'] = pad
if not self.toolButtons.buttons[(1, 0)].isHidden():
stylus = self.stylus.get_config()
# if stylus['stylus'] != self.configs[self.dev][self.config]['stylus']:
write = True
self.configs[self.dev][self.config]['stylus'] = stylus['stylus']
# if stylus['eraser'] != self.configs[self.dev][self.config]['eraser']:
write = True
self.configs[self.dev][self.config]['eraser'] = stylus['eraser']
if not self.toolButtons.buttons[(2, 0)].isHidden():
touch = self.touch.get_config()
if touch != self.configs[self.dev][self.config]['touch']:
write = True
self.configs[self.dev][self.config]['touch'] = touch
# TODO: cursor
if not self.toolButtons.buttons[(3, 0)].isHidden():
tmp = 1
if write:
reply = None
if self.toggle is False and self.load is False:
reply = QMessageBox.question(self, 'Save Config',
"Write \"%s\" config file?" % self.config,
QMessageBox.Yes, QMessageBox.No)
# update config if toggle is set or save is called
if self.toggle or reply == QMessageBox.Yes:
home = "%s/.wacom-gui" % expanduser("~")
conf_path = os.path.join(home, self.dev)
conf_file = os.path.join(conf_path, "%s.json" % self.config)
if not os.path.exists(conf_path):
os.mkdir(conf_path)
elif os.path.exists(conf_file):
os.rename(conf_file, "%s.bak" % conf_file)
with open(conf_file, 'w') as outfile:
json.dump(self.configs[self.dev][self.config], outfile, sort_keys=True,
indent=4, separators=(',', ': '))
if os.path.exists(conf_file):
if os.path.exists("%s.bak" % conf_file):
os.remove("%s.bak" % conf_file)
# check if we need to update what config is loaded
default = {}
if self.dev is not None:
for idx, tablet in enumerate(self.tablet_data.tablets[self.dev]):
if 'config' in tablet.keys():
# check if toggle enabled
toggle = 0
if 'pad' in self.configs[self.dev][tablet['config']]:
for button in self.configs[self.dev][tablet['config']]['pad']['buttons'].keys():
if self.configs[self.dev][tablet['config']]['pad']['buttons'][button] == 'lhyper z':
toggle = 1
break
default[idx] = {'config': tablet['config'],
'toggle': toggle}
else:
default[idx] = {'config': 'default',
'toggle': 0}
conf_path = os.path.join("%s/.wacom-gui" % expanduser("~"), self.dev)
conf_file = os.path.join(conf_path, 'device_default')
with open(conf_file, 'w') as outfile:
json.dump(default, outfile, sort_keys=True,
indent=4, separators=(',', ': '))
def quickLoad(self):
self.load = True
for idx, button in enumerate(self.tabletButtons.btn_grp.buttons()):
self.tabletSelect(idx)
sys.exit()
def closeEvent(self, event):
self.updateConfigs()
event.accept()
self.deleteLater()
def stylus_to_css(source):
compiler = Stylus()
return u('<style>{css}</style>').format(
css=compiler.compile(source).strip())
def stylus_to_css(source):
compiler = Stylus()
return u('<style>{css}</style>').format(css=compiler.compile(source).strip())
def stylus_to_css(source):
compiler = Stylus(plugins={'nib': {}})
return as_unicode('<style>{css}</style>').format(
css=compiler.compile(source).strip())
