MadButterfly: pyink/FSM_window.py comparison

comparison pyink/FSM_window.py @ 1490:3f107ceee9c1

User can add transitions for states by popup menu

author	Thinker K.F. Li <thinker@codemud.net>
date	Sat, 30 Apr 2011 21:42:28 +0800
parents	1e607ce4bf7d
children	06c101bba830

comparison

equal deleted inserted replaced

-:1e607ce4bf7d
+:3f107ceee9c1
 import gtk
 import os
+import math
 import data_monitor
+import pybInkscape
 class FSM_window_base(object):
 _add_state_button = None
 _move_state_button = None
 _doc = None
 _domview = None
 _fsm_layer = None
 _control_layer = None
 _state = None
+_states = None
 trn_cond = None
 trn_g = None
 _arrow_node = None
 _path_node = None
 def __init__(self, trn_cond):
 self.trn_cond = trn_cond
 pass
-def init(self, doc, domview, state, fsm_layer, control_layer):
+def init(self, doc, domview, state, states, fsm_layer, control_layer):
 self._doc = doc
 self._domview = domview
 self._state = state
+self._states = states
 self._fsm_layer = fsm_layer
 self._control_layer = control_layer
 pass
 @staticmethod
 def _update_graph(path, arrow_node, path_node):
-import math
 path_txt = 'M %f,%f C %f,%f %f,%f %f,%f' % tuple(path)
 path_node.setAttribute('d', path_txt)
 path_node.setAttribute('style', 'stroke: #000000; stroke-width: 1; '
 'fill: none')
 parent.appendChild(trn_g)
 return trn_g, path_node, arrow_node
+def _gen_path(self):
+states = self._states
+target_name = self.target
+target_state = states[target_name]
+src_state = self._state
+src_x, src_y = src_state.xy
+src_r = src_state.r
+target_x, target_y = target_state.xy
+target_r = target_state.r
+src_target_v = (target_x - src_x, target_y - src_y)
+src_target_len = \
+math.sqrt(src_target_v[0] ** 2 + src_target_v[1] ** 2)
+distance = src_target_len - src_r - target_r
+distance3 = distance / 3
+src_target_uv = (src_target_v[0] / src_target_len,
+src_target_v[1] / src_target_len)
+c0x = src_x + src_target_uv[0] * src_r
+c0y = src_y + src_target_uv[1] * src_r
+c1x = c0x + src_target_uv[0] * distance3
+c1y = c0y + src_target_uv[1] * distance3
+c3x = target_x - src_target_uv[0] * target_r
+c3y = target_y - src_target_uv[1] * target_r
+c2x = c3x - src_target_uv[0] * distance3
+c2y = c3y - src_target_uv[1] * distance3
+path = [c0x, c0y, c1x, c1y, c2x, c2y, c3x, c3y]
+return path
 @property
 def path(self):
 domview = self._domview
 state_name = self._state.state_name
 trn_cond = self.trn_cond
 trn = domview.get_transition(state_name, trn_cond)
-return trn[3]
+path = trn[3]
+if not path:
+path = self._gen_path()
+pass
+return path
 @property
 def target(self):
 domview = self._domview
 state_name = self._state.state_name
 arrow_node = self._arrow_node
 path_node = self._path_node
 self._update_graph(path, arrow_node, path_node)
 pass
-def adjust_by_ends(self, states):
+def adjust_by_ends(self):
-import math
+states = self._states
 state = self._state
 state_name = state.state_name
 trn_cond = self.trn_cond
 path = self.path
 pass
 class FSM_state(object):
 _doc = None
 _domview = None
+_states = None
 _fsm_layer = None
 _control_layer = None
 state_name = None
 state_g = None
 _text_node = None
 _circle_node = None
 transitions = None
-from_states = None
+from_states = None          # There is one or more transitions
+# from these states (name).
 _state_g_hdl_id = None
 _selected_rect = None
 def __init__(self, state_name):
 self.state_name = state_name
 self.transitions = {}
 self.from_states = set()
 pass
-def init(self, doc, domview, fsm_layer, control_layer):
+def init(self, doc, domview, states, fsm_layer, control_layer):
 self._doc = doc
 self._domview = domview
+self._states = states
 self._fsm_layer = fsm_layer
 self._control_layer = control_layer
 pass
 def _update_graph(self, text_node, text_content, circle_node,
 domview = self._domview
 state_name = self.state_name
 conds = domview.all_transitions(state_name)
 return conds
+def _load_transition_domview(self, parent, condition):
+domview = self._domview
+states = self._states
+trn = FSM_transition(condition)
+trn.init(self._doc, domview, self, states,
+self._fsm_layer, self._control_layer)
+trn.draw(parent)
+self.transitions[condition] = trn
+pass
 def draw(self, parent):
-domview = self._domview
 state_name = self.state_name
 r = self.r
 x, y = self.xy
 state_g, text_node, text_content, circle_node = \
 self._text_node = text_node
 self._text_content = text_content
 self._circle_node = circle_node
 for trn_cond in self.all_transitions:
-trn = FSM_transition(trn_cond)
+self._load_transition_domview(parent, trn_cond)
-trn.init(self._doc, domview, self,
-self._fsm_layer, self._control_layer)
-trn.draw(parent)
-self.transitions[trn_cond] = trn
 pass
 pass
 def clear(self):
 state_g = self.state_g
 x, y = self.xy
 self._update_graph(text_node, text_content, circle_node, state_name,
 r, x, y)
 pass
-def tell_target_states(self, states):
+## \brief Tell states there are transitions to them.
+#
+# This function is only called when loading states of a FSM from
+# domview.  When loading, not all states was loaded that target
+# state may not in the memory.  So, we call this function after
+# all states being loaded.  Transitions added later does need to
+# call this function to notify end state.
+#
+def tell_target_states(self):
+states = self._states
 transitions = self.transitions
 target_state_names = [trn.target for trn in transitions.values()]
 target_states = [states[target_name]
 for target_name in target_state_names]
 state_name = self.state_name
 for target_state in target_states:
 target_state.from_states.add(state_name)
 pass
 pass
-def adjust_transitions(self, states):
+def adjust_transitions(self):
 import itertools
+states = self._states
 for trn in self.transitions.values():
-trn.adjust_by_ends(states)
+trn.adjust_by_ends()
 trn.update()
 pass
 state_name = self.state_name
 from_states = [states[from_state_name]
 in_state_transitions = [[trn for trn in state_transitions
 if trn.target == state_name]
 for state_transitions in states_transitions]
 in_transitions = itertools.chain(*in_state_transitions)
 for trn in in_transitions:
-trn.adjust_by_ends(states)
+trn.adjust_by_ends()
 trn.update()
 pass
+pass
+def add_transition(self, parent, condition, target_state):
+domview = self._domview
+state_name = self.state_name
+target_name = target_state.state_name
+domview.add_transition(state_name, condition, target_name)
+self._load_transition_domview(parent, condition)
+states = self._states
+target_state = states[target_name]
+target_state.from_states.add(state_name)
 pass
 pass
 class _FSM_move_state_mode(object):
 pass
 self._selected_state = None
 pass
 def handle_move_state_state(self, state, evtype, button, x, y):
-import pybInkscape
 window = self._window
-states = window._states
 def moving_state(item, evtype, button, x, y):
 if evtype == pybInkscape.PYSPItem.PYB_EVENT_BUTTON_RELEASE:
 window.ungrab_mouse()
 pass
 new_state_y = orign_state_y + start_y - y
 domview = self._domview
 domview.set_state_xy(state.state_name, x, y)
 state.update()
-state.adjust_transitions(states)
+state.adjust_transitions()
 state.show_selected()
 pass
 window = self._window
 class _FSM_add_state_mode(object):
 __metaclass__ = data_monitor.data_monitor
 __data_monitor_prefix__ = 'on_'
+_window = None
+_domview = None
 _saved_x = 0
 _saved_y = 0
+_select_state = None
 def __init__(self, window, domview_ui):
 super(_FSM_add_state_mode, self).__init__()
 self._window = window
 window.hide_state_editor()
 pass
 def on_add_state_background(self, item, evtype, button, x, y):
-import pybInkscape
 window = self._window
 if evtype == pybInkscape.PYSPItem.PYB_EVENT_BUTTON_RELEASE and \
 button == 1:
 self._saved_x = x
 self._saved_y = y
 window.show_state_editor()
 pass
 pass
+def _handle_select_transition_target(self, state, evtype, button, x, y):
+if evtype != pybInkscape.PYSPItem.PYB_EVENT_BUTTON_RELEASE:
+return
+if button != 1:
+return
+if state == self._select_state:
+self.deactivate()
+self.activate()
+return
+window = self._window
+fsm_layer = window._fsm_layer
+target_state = state
+src_state = self._select_state
+cond = ''
+src_state.add_transition(fsm_layer, cond, target_state)
+pass
+def _handle_add_transition(self, *args):
+def restore_bg(item, evtype, *args):
+if evtype != pybInkscape.PYSPItem.PYB_EVENT_BUTTON_PRESS:
+return
+self.deactivate()
+self.activate()
+pass
+window = self._window
+window.ungrab_bg()
+window.grab_bg(restore_bg)
+window.ungrab_state()
+window.grab_state(self._handle_select_transition_target)
+pass
 def _handle_state_mouse_events(self, state, evtype, button, x, y):
-import pybInkscape
 if evtype == pybInkscape.PYSPItem.PYB_EVENT_BUTTON_RELEASE and \
 button == 3:
+self._select_state = state
 window = self._window
 window.popup_state_menu()
 pass
 pass
 window._emit_leave_mode()
 window.ungrab_all()
 window.grab_bg(self.on_add_state_background)
 window.grab_state(self._handle_state_mouse_events)
+window.grab_add_transition(self._handle_add_transition)
 pass
 def deactivate(self):
 pass
 pass
 _leave_mode_cb = None
 _move_state_mode = None
 _add_state_mode = None
 _state_mouse_event_handler = None
+_add_transition_cb = None
 def __init__(self, domview_ui, close_cb, destroy_cb):
 super(FSM_window, self).__init__()
 self._locker = domview_ui
 def _draw_state_domview(self, state_name):
 domview = self._domview
 doc = self._doc()
 fsm_layer = self._fsm_layer
+states = self._states
 state = FSM_state(state_name)
-state.init(doc, domview, self._fsm_layer, self._control_layer)
+state.init(doc, domview, states, self._fsm_layer, self._control_layer)
 self._states[state_name] = state
 state.draw(fsm_layer)
 pass
 def ungrab_all(self):
 self.ungrab_bg()
 self.ungrab_mouse()
 self.ungrab_state()
+self.ungrab_add_transition()
 pass
 def on_state_mouse_event(self, state, evtype, button, x, y):
 if self._state_mouse_event_handler:
 self._state_mouse_event_handler(state, evtype, button, x, y)
 self._state_mouse_event_handler = callback
 pass
 def ungrab_state(self):
 self._state_mouse_event_handler = None
+pass
+def grab_add_transition(self, callback):
+assert self._add_transition_cb is None
+self._add_transition_cb = callback
+pass
+def ungrab_add_transition(self):
+self._add_transition_cb = None
 pass
 def _load_new_state(self, state_name):
 states = self._states
 #
 def _load_new_state_incr(self, state_name):
 self._load_new_state(state_name)
 states = self._states
 state = states[state_name]
-state.tell_target_states(states)
+state.tell_target_states()
 pass
 def _rebuild_from_states(self):
 states = self._states
 domview = self._domview
 state_names = domview.all_state_names()
 for state_name in state_names:
 state = states[state_name]
-state.tell_target_states(states)
+state.tell_target_states()
 pass
 pass
 def _update_view(self):
 self._clear_view()
 self._set_leave_mode_cb(lambda: mode.deactivate())
 pass
 def on_state_apply_clicked(self, *args):
 self._add_state_mode.handle_new_state()
+pass
+def on_add_transition_activate(self, *args):
+if self._add_transition_cb:
+self._add_transition_cb(*args)
+pass
 pass
 def _install_test_data(self):
 self._init_layers()

Mercurial > MadButterfly

comparison pyink/FSM_window.py @ 1490:3f107ceee9c1