def __init__(self): self.global_keymap = Keymap() self.global_keymap.register_key(Key(pygame.KMOD_CTRL, pygame.K_q), keydown_noarg(self._quit)) self.global_keymap.activate() self.mouse_map = MouseMap() self.lc = LoopingCall(self._iteration)
def _register_keys(self): self.parenting_keymap = Keymap() r = self.keymap.register_key r(self.key_create_node, keydown_noarg(self._create_new_node)) r(self.key_cycle_layout, keydown_noarg(self._cycle_layout_engine)) r(self.key_save, keydown_noarg(self._save)) r(self.key_load, keydown_noarg(self._load)) r(self.key_export_snapshot, keydown_noarg(self._export_snapshot)) self._set_next_keymap()
def __init__(self): self.focus_keymap = Keymap() self.focus_keymap.obs_activation.add_observer(self, '_keymap_') self.keymap = Keymap() self.keymap.set_next_keymap(self.focus_keymap) self._prev_frame_colors = [] self._anim_pos = MovingPos() self.selectable = ValueContainer(True)
class Loop(object): fps = 20 def __init__(self): self.global_keymap = Keymap() self.global_keymap.register_key(Key(pygame.KMOD_CTRL, pygame.K_q), keydown_noarg(self._quit)) self.global_keymap.activate() self.mouse_map = MouseMap() self.lc = LoopingCall(self._iteration) def _handle_event(self, event): if event.type == pygame.QUIT: self._quit() if event.type in [pygame.KEYDOWN, pygame.KEYUP]: self.global_keymap.key_event(event) if event.type in [pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP, pygame.MOUSEMOTION]: self.mouse_map.mouse_event(MouseEvent(event)) def _quit(self): """Quits the program""" self.lc.stop() def _stop(self, e): reactor.stop() def loop(self, display, widget): self.display = display self.widget = widget self.global_keymap.set_next_keymap(self.widget.keymap) reactor.callWhenRunning(self._start_loop) reactor.run() def _start_loop(self): d = self.lc.start(1. / self.fps) d.addCallback(self._stop) d.addErrback(twisted.python.log.err) def _iteration(self): draw.offset.step() for event in pygame.event.get(): self._handle_event(event) draw.fill(self.display, (0, 0, 0)) self.widget.update() self.widget.draw(self.display, (0, 0)) pygame.display.flip()
class GraphWidget(Widget): bg_color=(0,0,0) activated_bg_color=(10,10,20) key_create_node = Key(pygame.KMOD_CTRL, pygame.K_a) key_delete_node = Key(pygame.KMOD_CTRL, pygame.K_d) key_next_node = Key(0, pygame.K_TAB) key_prev_node = Key(pygame.KMOD_SHIFT, pygame.K_TAB) key_select_node_right = Key(0, pygame.K_RIGHT) key_select_node_left = Key(0, pygame.K_LEFT) key_select_node_up = Key(0, pygame.K_UP) key_select_node_down = Key(0, pygame.K_DOWN) key_connect = Key(pygame.KMOD_CTRL, pygame.K_RETURN) key_disconnect = Key(pygame.KMOD_CTRL, pygame.K_BACKSPACE) key_cycle_layout = Key(pygame.KMOD_CTRL, pygame.K_k) #key_export_dot = Key(pygame.KMOD_CTRL, pygame.K_) key_export_snapshot = Key(pygame.KMOD_CTRL, pygame.K_x) key_save = Key(pygame.KMOD_CTRL, pygame.K_s) key_load = Key(pygame.KMOD_CTRL, pygame.K_l) def __init__(self, size, *args, **kw): Widget.__init__(self, *args, **kw) self._size = MovingValue(Point, final=Point(size)) self.nodes = set() self.edges = set() self.node_widgets = Dict() self.edge_widgets = Dict() self.sorted_widgets = SortedItems(self.node_widgets) self.layout = Layout() self.selected_widget_index = None self._update_index() self._node_link_start_pos = None self._node_link_source_node = None self._node_link_color = None self._register_keys() self._save_next_display_update = False def __getstate__(self): d = Widget.__getstate__(self) del d['parenting_keymap'] return d def __setstate__(self, d): Widget.__setstate__(self, d) self._register_keys() def _register_keys(self): self.parenting_keymap = Keymap() r = self.keymap.register_key r(self.key_create_node, keydown_noarg(self._create_new_node)) r(self.key_cycle_layout, keydown_noarg(self._cycle_layout_engine)) r(self.key_save, keydown_noarg(self._save)) r(self.key_load, keydown_noarg(self._load)) r(self.key_export_snapshot, keydown_noarg(self._export_snapshot)) self._set_next_keymap() def get_size(self): return tuple(self._size.current) def set_size(self, p): self._size.final = p size = property(get_size, set_size) def _node_connect(self, e): for node in e.source, e.target: if node not in self.nodes: self.add_node(node) if e not in self.edges: self.add_edge(e) def _node_disconnect(self, e): self.remove_edge(e) def update_edges_lines(self, widget, node): center = Point(widget.final_rect().center) for edge in node.connections['in']: edge_w = self.edge_widgets[edge] edge_w.line.final[-1] = center.copy() edge_w.line.reset() for edge in node.connections['out']: edge_w = self.edge_widgets[edge] edge_w.line.final[0] = center.copy() edge_w.line.reset() def _node_widget_loc_pos_set(self, widget, node, new_pos): self.update_edges_lines(widget, node) def _node_widget_loc_size_set(self, widget, node, new_size): self.update_edges_lines(widget, node) def add_edge(self, edge): edge.obs.add_observer(self, '_edge_') self.edges.add(edge) if edge.source not in self.node_widgets: self.add_node(edge.source) source = self.node_widgets[edge.source].final_rect().center if edge.target not in self.node_widgets: self.add_node(edge.target) target = self.node_widgets[edge.target].final_rect().center w = EdgeWidget(edge, partial(self.node_widgets.get), MovingLine(list, [Point(source), Point(target)])) self.edge_widgets[edge] = w self.update_layout() def remove_edge(self, edge): edge.obs.remove_observer(self) del self.edge_widgets[edge] self.edges.remove(edge) self.update_layout() def add_node(self, node): if node in self.nodes: return self.nodes.add(node) w = NodeWidget(node) self.node_widgets[node] = w node.obs.add_observer(self, '_node_') w.obs_loc.add_observer(self, '_node_widget_loc_', w, node) loop.loop.mouse_map.push_area(w.mouse_area, partial(self._widget_mouse_event, node, w)) # They might be adding a node that is connected to some other, # yet-to-be added nodes for edge in node.iter_all_connections(): self.add_edge(edge) self.update_layout() return w def remove_node(self, node): node.disconnect_all() w = self.node_widgets[node] loop.loop.mouse_map.remove_area(w.mouse_area) w.obs_loc.remove_observer(self) node.obs.remove_observer(self) del self.node_widgets[node] self.nodes.remove(node) self._update_index() if self._node_link_source_node: self._node_link_source_node = None self.update_layout() return w def generate_groups(self): groups = {'0':[]} for node in self.nodes: groups['0'].append(node) return groups def update_layout(self): groups = self.generate_groups() self.layout.update(groups, self.size, self.node_widgets, self.edge_widgets) def update(self): if self.node_widgets: import math # todo rewrite this shitty code sizes = {} slots = {} slot_places = {} average = 0 num = len(self.node_widgets) for w in self.node_widgets.values(): size = w.reset_max_text_size() sizes[w] = size for w, size in sizes.iteritems(): dist = int(round(math.log(size + 1)/2.)) slot = dist slots.setdefault(slot, size) slots[slot] = min(slots[slot],size) slot_places[w] = slot for w,slot in slot_places.iteritems(): size = sizes[w] new_max_size = slots[slot] if new_max_size < size: w.reset_max_text_size(new_max_size) w.update() ## for w in self.node_widgets.values(): ## w.reset_max_text_size() ## w.update() for w in self.edge_widgets.itervalues(): w.update() self._size.update() def _draw(self, surface, pos): for w in self.edge_widgets.values(): p = Point(pos) w._draw(surface, pos) for w in self.node_widgets.values(): # for our children, pos is the parent's pos offset # because of how NodeWidget works. w._draw(surface, pos) if self._node_link_start_pos is not None: n,w = self.selected() if w is not None: start_pos = self._node_link_start_pos() end_pos = self._node_link_end_pos() draw.line(surface, self._node_link_color, start_pos, end_pos) if self._save_next_display_update: self._save_next_display_update = None draw.save(surface.subsurface(pygame.Rect(pos, self.size)), self._save_next_display_update) def selected(self): if self.selected_widget_index is None: return None, None return self.sorted_widgets[self.selected_widget_index] def _set_next_keymap(self): self.keymap.set_next_keymap(self.parenting_keymap) if self.selected_widget_index is not None: self.parenting_keymap.set_next_keymap(self.selected()[1].keymap) r = self.parenting_keymap.register_key r(self.key_delete_node, keydown_noarg(self._delete_selected_node)) r(self.key_next_node, keydown_noarg(self._next_node)) r(self.key_prev_node, keydown_noarg(self._prev_node)) r(self.key_select_node_right, keydown_noarg(self._select_node_right)) r(self.key_select_node_left, keydown_noarg(self._select_node_left)) r(self.key_select_node_up, keydown_noarg(self._select_node_up)) r(self.key_select_node_down, keydown_noarg(self._select_node_down)) if self.key_connect not in self.parenting_keymap: r(self.key_connect, keydown_noarg(self._start_connect)) if self.key_disconnect not in self.parenting_keymap: r(self.key_disconnect, keydown_noarg(self._start_disconnect)) else: ur = self.parenting_keymap.unregister_key ur(self.key_next_node) ur(self.key_prev_node) ur(self.key_select_node_right) ur(self.key_select_node_left) ur(self.key_select_node_up) ur(self.key_select_node_down) ur(self.key_delete_node) ur(self.key_connect) ur(self.key_disconnect) self.parenting_keymap.set_next_keymap(self.focus_keymap) def _set_index(self, index): if self.selected_widget_index != index: self.selected_widget_index = index self._update_index() def _update_index(self): if not self.node_widgets: self.selected_widget_index = None elif self.selected_widget_index is not None: self.selected_widget_index %= len(self.sorted_widgets) self._set_next_keymap() def _find_widget_index(self, w): for i, (node, widget) in enumerate(self.sorted_widgets): if w == widget: return i def _add_index(self, amount): if self.selected_widget_index is None: index = 0 else: index = self.selected_widget_index l = len(self.sorted_widgets) index += amount index %= l self._set_index(index) def _next_node(self): '''Next node''' self._add_index(1) def _prev_node(self): '''Previous node''' self._add_index(-1) def _select_node_right(self): '''Select the next node to the right''' def dist(pos1, pos2): if pos1[0] < pos2[0]: return None return pos1[0] - pos2[0] self._select_node_dir(dist) def _select_node_left(self): '''Select the next node to the left''' def dist(pos1, pos2): if pos1[0] > pos2[0]: return None return pos2[0] - pos1[0] self._select_node_dir(dist) def _select_node_up(self): '''Select the next node above''' def dist(pos1, pos2): if pos1[1] > pos2[1]: return None return pos2[1] - pos1[1] self._select_node_dir(dist) def _select_node_down(self): '''Select the next node below''' def dist(pos1, pos2): if pos1[1] < pos2[1]: return None return pos1[1] - pos2[1] self._select_node_dir(dist) def _select_node_dir(self, distance_between): closest_right = None min_dist = None n, w = self.selected() if not w: return for widget in self.node_widgets.itervalues(): if widget == w: continue dist = distance_between(widget.pos, w.pos) if dist is None: continue if closest_right is None or dist < min_dist: closest_right = widget min_dist = dist if closest_right is not None: i = self._find_widget_index(closest_right) self._set_index(i) def _create_new_node(self): '''Create new node''' n = Graph.Node() w = self.add_node(n) self._set_index(self._find_widget_index(w)) def _delete_selected_node(self): '''Delete selected node''' n, w = self.sorted_widgets[self.selected_widget_index] self._add_index(1) self.remove_node(n) def _node_linking_started(self, key, start_func, connect_func, color, doc): r = self.parenting_keymap.register_key ur = self.parenting_keymap.unregister_key start_node, start_node_widget = self.selected() assert start_node is not None def _end_connect(): ur(key) r(key, keydown_noarg(start_func)) end_node, end_node_widget = self.sorted_widgets[self.selected_widget_index] self._node_link_func(start_node, end_node) self._node_link_start_pos = None self._node_link_end_pos = None _end_connect.__doc__ = doc def _start_pos(): return start_node_widget.rect().center def _end_pos(): n, w = self.selected() if w is None: return None return w.rect().center ur(key) r(key, keydown_noarg(_end_connect)) self._node_link_start_pos = _start_pos self._node_link_end_pos = _end_pos self._node_link_color = color self._node_link_func = connect_func def _connect_func(self, node1, node2): node1.connect_node(node2) def _disconnect_func(self, node1, node2): node1.disconnect_node(node2) def _start_connect(self): '''Sets the source node to connect''' self._node_linking_started(self.key_connect, self._start_connect, self._connect_func, (0,255,0), "Sets the target node to connect") def _start_disconnect(self): '''Sets the source node to disconnect''' self._node_linking_started(self.key_disconnect, self._start_disconnect, self._disconnect_func, (255,0,0), "Sets the target node to disconnect") def _widget_mouse_event(self, node, widget, event): #print event connect_mod = pygame.key.get_mods() & pygame.KMOD_SHIFT #disconnect_mod = pygame.key.get_modes() & pygame.KMOD_SHIFT if event.type == pygame.MOUSEBUTTONDOWN: i = self._find_widget_index(widget) self._set_index(i) if connect_mod and self._node_link_start_pos is None: def _start_pos(): return widget.rect().center self._node_link_source_node = node self._node_link_start_pos = _start_pos self._node_link_end_pos = pygame.mouse.get_pos self._node_link_color = (0,255,0) self._node_link_func = self._connect_func elif event.type == pygame.MOUSEBUTTONUP: if self._node_link_source_node is not None: self._node_link_start_pos = None self._node_link_end_pos = None self._node_link_func(self._node_link_source_node, node) self._node_link_source_node = None self._node_link_color = None def _cycle_layout_engine(self): '''Change to the next layout engine''' self.layout.cycle_layout_engines() self.update_layout() def _save(self): '''Save''' import pickle f=open('save.pkl', 'wb') pickle.dump(self.nodes,f,2) def _load(self): '''Load''' import pickle f=open('save.pkl', 'rb') nodes = pickle.load(f) for node in tuple(self.nodes): self.remove_node(node) self._set_next_keymap() for node in nodes: # TODO if we are loading nodes in addition to existing nodes, # make sure ID's are re-allocated to prevent collisions. node.id = Graph.persistent_id(node) for edge in node.iter_all_connections(): edge.id = Graph.persistent_id(edge) for node in nodes: self.add_node(node) def _export_dot(self): '''Export the graph to a .dot file''' d = Graph.generate_dot(self.generate_groups()) print d open('save.dot', 'wb').write(d) def _export_snapshot(self): '''Export the graph to a snapshot image''' self._save_next_display_update = 'snapshot.bmp'
def __setstate__(self, d): for k,v in d.iteritems(): self.__dict__[k] = v self.focus_keymap = Keymap() self.keymap = Keymap() self._register_keys()
class NodeWidget(Widget): bg_color=(10,10,100) activated_bg_color=(40,40,160) fg_color=(70,70,150) activated_fg_color=(100,100,250) key_stop_edit=Key(0, pygame.K_ESCAPE) def __init__(self, node, *args, **kw): self.node = node self.style = style._make_style() self.text_widget = TextEdit(self.style, self._get_text, self._set_text, [all_printable], {'\r':'\n'}) self.node.obs.add_observer(self, '_node_') Widget.__init__(self, *args, **kw) self._size = MovingValue(Point) self._pos = MovingValue(Point) from Shapes.Ellipse import Ellipse self.shape = Ellipse(pygame.Rect(0,0,1,1)) self.obs_loc = Observable() self._register_keys() self.reset_max_text_size() self.mouse_area = MouseArea(self.in_bounds) def __getstate__(self): d= self.__dict__.copy() del d['focus_keymap'] del d['keymap'] return d def __setstate__(self, d): for k,v in d.iteritems(): self.__dict__[k] = v self.focus_keymap = Keymap() self.keymap = Keymap() self._register_keys() def _register_keys(self): r = self.focus_keymap.register_key r(Key(pygame.KMOD_CTRL, pygame.K_RIGHT), keydown_noarg(self._move_right)) r(Key(pygame.KMOD_CTRL, pygame.K_LEFT), keydown_noarg(self._move_left)) r(Key(pygame.KMOD_CTRL, pygame.K_UP), keydown_noarg(self._move_up)) r(Key(pygame.KMOD_CTRL, pygame.K_DOWN), keydown_noarg(self._move_down)) r(Key(0, pygame.K_RETURN), keydown_noarg(self._edit_value)) def in_bounds(self, p): return self.rect().collidepoint(tuple(p)) def _get_text(self): if self.node.value is None: return '' return str(self.node.value) def _set_text(self, text): self.node.value = text self._update_text_size() def reset_max_text_size(self, value=None): # returns the calculated actual size if value is None: value = FONT_SIZE_ABSOLUTE_MAX self.max_font_size = value return self.calc_text_size() def calc_text_size(self): min_font_size = 2 ratio = 0.7 yratio = 1 size = self.style.font_size self.text_widget.update() while ((self.text_widget.size[0] < self._size.final[0]*ratio or self.text_widget.size[1] < self._size.final[1]*yratio) and self.style.font_size < min(self.max_font_size, FONT_SIZE_ABSOLUTE_MAX)): self.style.font_size = min(self.style.font_size + 1, FONT_SIZE_ABSOLUTE_MAX) self._update_text_size() while ((self.text_widget.size[0] > self._size.final[0]*ratio or self.text_widget.size[1] > self._size.final[1]*yratio) and self.style.font_size > min_font_size or self.style.font_size > self.max_font_size): self.style.font_size -= 1 self._update_text_size() return self.style.font_size def _update_text_size(self, new_size=None): if new_size is not None: self.style.font_size = new_size self.text_widget.set_style(self.style) self.text_widget.update(force=True) def get_size(self): return tuple(self._size.current) def set_size(self, p): p = Point(p) self._size.final = p self._update_text_size() self.obs_loc.notify.size_set(p) size = property(get_size, set_size) def get_pos(self): return tuple(self._pos.current) def set_pos(self, p): p = Point(p) self._pos.final = p self.obs_loc.notify.pos_set(p) pos = property(get_pos, set_pos) def rect(self): s = self.size return pygame.Rect(self.pos[0],self.pos[1],s[0],s[1]) def final_rect(self): s = self._size.final p = self._pos.final return pygame.Rect(p[0],p[1],s[0],s[1]) def _node_connect(self, e): pass def _node_disconnect(self, e): pass def update(self): self.text_widget.update() self._update_text_size() self._size.update() self._pos.update() self.shape.rect = self.rect() def _draw(self, surface, pos_offset): self.shape.paint(pos_offset, surface, self.fg_color, self.bg_color) self.text_widget.draw(surface, tuple(Point(pos_offset) + Point(self.rect().center) - Point(self.text_widget.size)/2)) def _move_right(self): '''move right''' self.pos = Point(self.pos) + Point((5,0)) def _move_left(self): '''move left''' self.pos = Point(self.pos) + Point((-5,0)) def _move_up(self): '''move up''' self.pos = Point(self.pos) + Point((0,-5)) def _move_down(self): '''move down''' self.pos = Point(self.pos) + Point((0,5)) def _edit_value(self): '''Edit value''' self.keymap.set_next_keymap(self.text_widget.focus_keymap) self.text_widget._start_editing() self.keymap.register_key(self.key_stop_edit, keydown_noarg(self._stop_edit_value)) def _stop_edit_value(self): '''Stop editing value''' self.text_widget._stop_editing() self.keymap.set_next_keymap(self.focus_keymap) self.keymap.unregister_key(self.key_stop_edit)
class Widget(object): # frame_color is consulted first, and allowed to be None for no # frame. frame_color = None frame_width = 1 bg_color = None use_rounded_rect = True activated_frame_color = (40, 40, 255) activated_bg_color = (30, 30, 90) def __init__(self): self.focus_keymap = Keymap() self.focus_keymap.obs_activation.add_observer(self, '_keymap_') self.keymap = Keymap() self.keymap.set_next_keymap(self.focus_keymap) self._prev_frame_colors = [] self._anim_pos = MovingPos() self.selectable = ValueContainer(True) def _keymap_activated(self): self.got_focus() def _keymap_deactivated(self): self.lost_focus() def push_frame(self, frame_color=_dontchange, bg_color=_dontchange): self._prev_frame_colors.append((self.frame_color, self.bg_color)) if frame_color is not _dontchange: self.frame_color = frame_color if bg_color is not _dontchange: self.bg_color = bg_color def pop_frame(self): self.frame_color, self.bg_color = self._prev_frame_colors.pop() def got_focus(self): self.push_frame(frame_color=self.activated_frame_color, bg_color=self.activated_bg_color) def lost_focus(self): self.pop_frame() def draw(self, surface, pos): self._anim_pos.set_target(pos) self._anim_pos.update(0.6) pos = self._anim_pos.current_pos self.draw_background(surface, pos) self._draw(surface, pos) self.draw_frame(surface, pos) def draw_background(self, surface, pos): if self.bg_color is not None: r = pygame.Rect(pos, self.size) gui.draw.rect(surface, self.bg_color, r, 0) def draw_frame(self, surface, pos): if self.frame_color is not None: r = pygame.Rect(pos, self.size) r.inflate_ip(-self.frame_width, -self.frame_width) # Half of each side if self.use_rounded_rect: dr = partial(gui.draw.rounded.rounded_rect, corner_radius=5) else: dr = gui.draw.rect dr(surface, self.frame_color, r, self.frame_width) def _draw(self, surface, pos): raise NotImplementedError() def update(self): raise NotImplementedError()