171 lines
6.2 KiB
Python
171 lines
6.2 KiB
Python
'''
|
|
Copyright (C) 2023 CG Cookie
|
|
http://cgcookie.com
|
|
hello@cgcookie.com
|
|
|
|
Created by Jonathan Denning, Jonathan Williamson, and Patrick Moore
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
'''
|
|
|
|
from ..addon_common.common.debug import debugger
|
|
from ..addon_common.common.drawing import Cursors
|
|
from ..addon_common.common.fsm import FSM
|
|
from ..addon_common.common.drawing import DrawCallbacks
|
|
from ..addon_common.common.functools import find_fns
|
|
|
|
def rfwidget_callback_decorator(event, fn):
|
|
if not hasattr(fn, '_rfwidget_callback'):
|
|
fn._rfwidget_callback = []
|
|
fn._rfwidget_callback += [event]
|
|
return fn
|
|
|
|
|
|
class RFWidget:
|
|
'''
|
|
Assumes that direct subclass will have singleton instance (shared FSM among all instances of that subclass and any subclasses)
|
|
'''
|
|
registry = []
|
|
|
|
@classmethod
|
|
def __init_subclass__(cls, *args, **kwargs):
|
|
# print('rfwidget subclass', cls, super(cls))
|
|
if not hasattr(cls, '_rfwidget_index'):
|
|
# add cls to registry (might get updated later) and add FSM,Draw
|
|
cls._rfwidget_index = len(RFWidget.registry)
|
|
RFWidget.registry.append(cls)
|
|
else:
|
|
# update registry, but do not add new FSM
|
|
RFWidget.registry[cls._rfwidget_index] = cls
|
|
super().__init_subclass__(*args, **kwargs)
|
|
|
|
|
|
#####################################################
|
|
# function decorators for different events
|
|
|
|
@staticmethod
|
|
def on_init(fn): return rfwidget_callback_decorator('init', fn)
|
|
@staticmethod
|
|
def on_reset(fn): return rfwidget_callback_decorator('reset', fn)
|
|
@staticmethod
|
|
def on_timer(fn): return rfwidget_callback_decorator('timer', fn)
|
|
@staticmethod
|
|
def on_target_change(fn): return rfwidget_callback_decorator('target change', fn)
|
|
@staticmethod
|
|
def on_view_change(fn): return rfwidget_callback_decorator('view change', fn)
|
|
@staticmethod
|
|
def on_action(action_name):
|
|
def wrapper(fn):
|
|
nonlocal action_name
|
|
fn._rfwidget_action_name = action_name
|
|
return rfwidget_callback_decorator('action', fn)
|
|
return wrapper
|
|
@staticmethod
|
|
def on_actioning(action_name):
|
|
def wrapper(fn):
|
|
nonlocal action_name
|
|
fn._rfwidget_action_name = action_name
|
|
return rfwidget_callback_decorator('actioning', fn)
|
|
return wrapper
|
|
|
|
def __init__(self, rftool, *, start='main', reset_state=None, **kwargs):
|
|
self.rftool = rftool
|
|
self.rfcontext = rftool.rfcontext
|
|
self.actions = rftool.rfcontext.actions
|
|
self.redraw_on_mouse = False
|
|
self._gather_callbacks()
|
|
self._fsm = FSM(self, start=start, reset_state=reset_state)
|
|
self._draw = DrawCallbacks(self)
|
|
self._callback_widget('init', **kwargs)
|
|
# self._init_action_callback()
|
|
self._reset()
|
|
|
|
def _fsm_in_main(self):
|
|
return self._fsm.state in {'main'}
|
|
|
|
def _callback_widget(self, event, *args, **kwargs):
|
|
if event != 'timer':
|
|
#print('callback', self, event, self._widget_callbacks.get(event, []))
|
|
pass
|
|
if event not in self._widget_callbacks: return
|
|
for fn in self._widget_callbacks[event]:
|
|
fn(self, *args, **kwargs)
|
|
|
|
def _callback_tool(self, event, action_name, *args, **kwargs):
|
|
if event != 'timer':
|
|
#print('callback', self, event, self._tool_callbacks.get(event, []))
|
|
pass
|
|
if event not in self._tool_callbacks: return
|
|
for fn in self._tool_callbacks[event]:
|
|
if fn._rfwidget_action_name != action_name: continue
|
|
fn(self.rftool, *args, **kwargs)
|
|
|
|
def _gather_callbacks(self):
|
|
widget_fns = find_fns(self, '_rfwidget_callback')
|
|
self._widget_callbacks = {
|
|
mode: [fn for (modes, fn) in widget_fns if mode in modes]
|
|
for mode in [
|
|
'init', # called when RF starts up
|
|
'reset', # called when RF switches into tool or undo/redo
|
|
'timer', # called every timer interval
|
|
'target change', # called whenever rftarget has changed (selection or edited)
|
|
'view change', # called whenever view has changed
|
|
]
|
|
}
|
|
rftool_fns = find_fns(self.rftool, '_rfwidget_callback')
|
|
self._tool_callbacks = {
|
|
mode: [fn for (modes, fn) in rftool_fns if mode in modes]
|
|
for mode in [
|
|
'action', # called when user performs widget action, per instance!
|
|
'actioning', # called when user is performing widget action, per instance!
|
|
]
|
|
}
|
|
|
|
def callback_actions(self, action_name, *args, **kwargs):
|
|
self._callback_tool('action', action_name, *args, **kwargs)
|
|
|
|
def callback_actioning(self, action_name, *args, **kwargs):
|
|
self._callback_tool('actioning', action_name, *args, **kwargs)
|
|
|
|
def _reset(self):
|
|
self._fsm.force_reset()
|
|
self._callback_widget('reset')
|
|
self._update_all()
|
|
|
|
def _fsm_update(self):
|
|
return self._fsm.update()
|
|
|
|
def _update_all(self):
|
|
self._callback_widget('timer')
|
|
self._callback_widget('target change')
|
|
self._callback_widget('view change')
|
|
|
|
@staticmethod
|
|
def dirty_when_done(fn):
|
|
def wrapper(*args, **kwargs):
|
|
ret = fn(*args, **kwargs)
|
|
RFWidget.rfcontext.dirty()
|
|
return ret
|
|
return wrapper
|
|
|
|
def set_cursor(self):
|
|
Cursors.set(self.rfw_cursor)
|
|
|
|
def inactive_passthrough(self): pass
|
|
|
|
def _draw_pre3d(self): self._draw.pre3d()
|
|
def _draw_post3d(self): self._draw.post3d()
|
|
def _draw_post2d(self): self._draw.post2d()
|
|
|