def __init__(self):
if window.flexx.init:
raise RuntimeError('Should not create global Flexx object more than once.')
# Init (overloadable) variables. These can be set by creating
# a window.flexx object *before* instantiating this class, or by
# setting them on this object before the init() is called.
self.is_notebook = False
self.is_exported = False
# Copy attributes from temporary object (e.g. is_notebook, require, ...)
for key in window.flexx.keys():
self[key] = window.flexx[key]
# We need a global main widget (shared between sessions)
self.need_main_widget = True # Used/set in ui/_widget.py
# Keep track of sessions
self._session_count = 0
self.sessions = {}
# Note: flexx.init() is not auto-called when Flexx is embedded
window.addEventListener('load', self.init, False)
window.addEventListener('unload', self.exit, False) # not beforeunload
def __init__(self):
if window.flexx.init:
raise RuntimeError(
'Should not create global Flexx object more than once.')
# Init (overloadable) variables. These can be set by creating
# a window.flexx object *before* instantiating this class, or by
# setting them on this object before the init() is called.
self.is_notebook = False
self.is_exported = False
# Copy attributes from temporary object (e.g. is_notebook, require, ...)
for key in window.flexx.keys():
self[key] = window.flexx[key]
# We need a global main widget (shared between sessions)
self.need_main_widget = True # Used/set in ui/_widget.py
# Keep track of sessions
self._session_count = 0
self.sessions = {}
# Note: flexx.init() is not auto-called when Flexx is embedded
window.addEventListener('load', self.init, False)
window.addEventListener('unload', self.exit, False) # not beforeunload
def _init_events(self):
# Disable context menu so we can handle RMB clicks
# Firefox is particularly stuborn with Shift+RMB, and RMB dbl click
for ev_name in ("contextmenu", "click", "dblclick"):
window.document.addEventListener(ev_name,
self._prevent_default_event, 0)
# Keep track of wheel event directed at the canvas
self.node.addEventListener("wheel", self._on_js_wheel_event, 0)
# If the canvas uses the wheel event for something, you'd want to
# disable browser-scroll when the mouse is over the canvas. But
# when you scroll down a page and the cursor comes over the canvas
# because of that, we don't want the canvas to capture too eagerly.
# This code only captures if there has not been scrolled elsewhere
# for about half a second.
if not window._wheel_timestamp:
window._wheel_timestamp = 0, ""
window.document.addEventListener("wheel", self._on_js_wheel_global,
0)
# Keep track of mouse events
self.node.addEventListener("mousedown", self._on_js_mouse_event, 0)
window.document.addEventListener("mouseup", self._on_js_mouse_event, 0)
window.document.addEventListener("mousemove", self._on_js_mouse_event,
0)
window.document.addEventListener("mousemove", self._tooltip_handler, 0)
self.node.addEventListener("mousedown", self._tooltip_handler, 0)
self.node.addEventListener("touchstart", self._tooltip_handler, 0)
self.node.addEventListener("touchmove", self._tooltip_handler, 0)
self.node.addEventListener("touchend", self._tooltip_handler, 0)
self.node.addEventListener("touchcancel", self._tooltip_handler, 0)
# Keep track of touch events
self.node.addEventListener("touchstart", self._on_js_touch_event, 0)
self.node.addEventListener("touchend", self._on_js_touch_event, 0)
self.node.addEventListener("touchcancel", self._on_js_touch_event, 0)
self.node.addEventListener("touchmove", self._on_js_touch_event, 0)
# Keep track of window size
window.addEventListener("resize", self._on_js_resize_event, False)
window.setTimeout(self._on_js_resize_event, 10)
def init_logging(self):
""" Setup logging so that messages are proxied to Python.
"""
if window.console.ori_log:
return # already initialized the loggers
# Keep originals
window.console.ori_log = window.console.log
window.console.ori_info = window.console.info or window.console.log
window.console.ori_warn = window.console.warn or window.console.log
window.console.ori_error = window.console.error or window.console.log
def log(msg):
window.console.ori_log(msg)
for session in self.sessions.values():
session.send_command("PRINT", str(msg))
def info(msg):
window.console.ori_info(msg)
for session in self.sessions.values():
session.send_command("INFO", str(msg))
def warn(msg):
window.console.ori_warn(msg)
for session in self.sessions.values():
session.send_command("WARN", str(msg))
def error(msg):
evt = dict(message=str(msg),
error=msg,
preventDefault=lambda: None)
on_error(evt)
def on_error(evt):
self._handle_error(evt)
on_error = on_error.bind(self)
# Set new versions
window.console.log = log
window.console.info = info
window.console.warn = warn
window.console.error = error
# Create error handler, so that JS errors get into Python
window.addEventListener('error', on_error, False)
def __init__(self, app_name, id, ws_url=None):
self.app = None # the root component (can be a PyComponent)
self.app_name = app_name
self.id = id
self.status = 1
self.ws_url = ws_url
self._component_counter = 0
self._disposed_ob = {'_disposed': True}
# Maybe this is JLab
if not self.id:
jconfig = window.document.getElementById('jupyter-config-data')
if jconfig:
try:
config = JSON.parse(jconfig.innerText)
self.id = config.flexx_session_id
self.app_name = config.flexx_app_name
except Exception as err:
print(err)
# Init internal variables
self._init_time = time()
self._pending_commands = [] # to pend raw commands during init
self._asset_count = 0
self._ws = None
self.last_msg = None
# self.classes = {}
self.instances = {}
self.instances_to_check_size = {}
if not window.flexx.is_exported:
self.init_socket()
# Initiate service to track resize
# Note that only toplevel widgets are tracked, and only once per sec
window.addEventListener('resize', self._check_size_of_objects, False)
window.setInterval(self._check_size_of_objects, 1000)
def __init__(self, app_name, id, ws_url=None):
self.app = None # the root component (can be a PyComponent)
self.app_name = app_name
self.id = id
self.status = 1
self.ws_url = ws_url
self._component_counter = 0
self._disposed_ob = {'_disposed': True}
# Maybe this is JLab
if not self.id:
jconfig = window.document.getElementById('jupyter-config-data')
if jconfig:
try:
config = JSON.parse(jconfig.innerText)
self.id = config.flexx_session_id
self.app_name = config.flexx_app_name
except Exception as err:
print(err)
# Init internal variables
self._init_time = time()
self._pending_commands = [] # to pend raw commands during init
self._asset_count = 0
self._ws = None
self.last_msg = None
# self.classes = {}
self.instances = {}
self.instances_to_check_size = {}
if not window.flexx.is_exported:
self.init_socket()
# Initiate service to track resize
# Note that only toplevel widgets are tracked, and only once per sec
window.addEventListener('resize', self._check_size_of_objects, False)
window.setInterval(self._check_size_of_objects, 1000)
def init_logging(self):
""" Setup logging so that messages are proxied to Python.
"""
if window.console.ori_log:
return # already initialized the loggers
# Keep originals
window.console.ori_log = window.console.log
window.console.ori_info = window.console.info or window.console.log
window.console.ori_warn = window.console.warn or window.console.log
window.console.ori_error = window.console.error or window.console.log
def log(msg):
window.console.ori_log(msg)
for session in self.sessions.values():
session.send_command("PRINT", str(msg))
def info(msg):
window.console.ori_info(msg)
for session in self.sessions.values():
session.send_command("INFO", str(msg))
def warn(msg):
window.console.ori_warn(msg)
for session in self.sessions.values():
session.send_command("WARN", str(msg))
def error(msg):
evt = dict(message=str(msg), error=msg, preventDefault=lambda: None)
on_error(evt)
def on_error(evt):
self._handle_error(evt)
on_error = on_error.bind(self)
# Set new versions
window.console.log = log
window.console.info = info
window.console.warn = warn
window.console.error = error
# Create error handler, so that JS errors get into Python
window.addEventListener('error', on_error, False)
# Draw rectangle for min max
y = y0 + (meas.min - mi) * vscale
h = (meas.max - meas.min) * vscale
ctx.fillRect(x, y, w, h)
# Draw rectangle for std
mean = meas.mean
std = (meas.magic / meas.n)**0.5 # Welford
st1 = max(meas.min, mean - std)
st2 = min(meas.max, mean + std)
y = y0 + (st1 - mi) * vscale
h = (st2 - st1) * vscale
ctx.fillRect(x, y, w, h)
y = y0 + (mean - mi) * vscale
mean_points.append((x + 0.3333 * w, y))
mean_points.append((x + 0.6666 * w, y))
# Draw mean
if len(mean_points) > 0:
ctx.beginPath()
ctx.moveTo(mean_points[0], mean_points[1])
for x, y in mean_points:
ctx.lineTo(x, y)
ctx.stroke()
window.addEventListener("load", on_init)
window.addEventListener("resize", on_resize)
window.addEventListener("hashchange", on_hash_change)
return
# Are we still logged in. User may have logged out in the mean time.
auth = get_auth_info()
if not auth:
return
# Apply
d = JSON.parse(await res.text())
set_auth_info_from_token(d.token)
if verbose:
console.warn("webtoken renewed")
# Renew token now, and set up to renew each hour
window.addEventListener("load", lambda: renew_webtoken())
register_long_timer_in_secs("renew_webtoken", 3600,
lambda: renew_webtoken(False))
# %% Storage
class AsyncStorage:
"""A kind of localstorage API, but async and without the 5MB memory
restriction, based on IndexedDB.
"""
_dbname = "timeturtle"
_dbstorename = "cache"
_dbversion = 1
