diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/Canvas.cpp | 1733 | ||||
| -rw-r--r-- | src/ganv-private.h | 23 | ||||
| -rw-r--r-- | src/group.c | 12 | ||||
| -rw-r--r-- | src/item.c | 150 | ||||
| -rw-r--r-- | src/module.c | 6 | ||||
| -rw-r--r-- | src/node.c | 10 | ||||
| -rw-r--r-- | src/port.c | 12 | ||||
| -rw-r--r-- | src/widget.c | 25 |
8 files changed, 959 insertions, 1012 deletions
diff --git a/src/Canvas.cpp b/src/Canvas.cpp index 27e3cab..533465e 100644 --- a/src/Canvas.cpp +++ b/src/Canvas.cpp @@ -28,7 +28,6 @@ #include <cassert> #include <cmath> #include <iostream> -#include <list> #include <map> #include <set> #include <sstream> @@ -84,24 +83,23 @@ static void ganv_canvas_unmap(GtkWidget* widget); static void ganv_canvas_realize(GtkWidget* widget); static void ganv_canvas_unrealize(GtkWidget* widget); static void ganv_canvas_size_allocate(GtkWidget* widget, - GtkAllocation* allocation); + GtkAllocation* allocation); static gint ganv_canvas_button(GtkWidget* widget, - GdkEventButton* event); + GdkEventButton* event); static gint ganv_canvas_motion(GtkWidget* widget, - GdkEventMotion* event); + GdkEventMotion* event); static gint ganv_canvas_expose(GtkWidget* widget, - GdkEventExpose* event); + GdkEventExpose* event); static gboolean ganv_canvas_key(GtkWidget* widget, - GdkEventKey* event); + GdkEventKey* event); static gboolean ganv_canvas_scroll(GtkWidget* widget, - GdkEventScroll* event); + GdkEventScroll* event); static gint ganv_canvas_crossing(GtkWidget* widget, - GdkEventCrossing* event); + GdkEventCrossing* event); static gint ganv_canvas_focus_in(GtkWidget* widget, - GdkEventFocus* event); + GdkEventFocus* event); static gint ganv_canvas_focus_out(GtkWidget* widget, - GdkEventFocus* event); -static void ganv_canvas_request_update_real(GanvCanvas* canvas); + GdkEventFocus* event); static GtkLayoutClass* canvas_parent_class; } @@ -113,12 +111,6 @@ static guint signal_disconnect; static GEnumValue dir_values[3]; -using std::cerr; -using std::endl; -using std::list; -using std::string; -using std::vector; - typedef std::set<GanvNode*> Items; #define FOREACH_ITEM(items, i) \ @@ -184,10 +176,18 @@ struct HeadTailOrder { } }; +/* Callback used when the root item of a canvas is destroyed. The user should + * never ever do this, so we panic if this happens. + */ +static void +panic_root_destroyed(GtkObject* object, gpointer data) +{ + g_error("Eeeek, root item %p of canvas %p was destroyed!", (void*)object, data); +} + struct GanvCanvasImpl { - GanvCanvasImpl(GanvCanvas* gobj) - : _gcanvas(gobj) - , _layout(GTK_LAYOUT(_gcanvas)) + GanvCanvasImpl(GanvCanvas* canvas) + : _gcanvas(canvas) , _connect_port(NULL) , _last_selected_port(NULL) , _drag_edge(NULL) @@ -195,30 +195,81 @@ struct GanvCanvasImpl { , _select_rect(NULL) , _select_start_x(0.0) , _select_start_y(0.0) - , _zoom(1.0) - , _font_size(0.0) , _drag_state(NOT_DRAGGING) - , _layout_idle_id(0) { + this->root = GANV_ITEM(g_object_new(ganv_group_get_type(), NULL)); + this->root->canvas = canvas; + g_object_ref_sink(this->root); + + this->direction = GANV_DIRECTION_RIGHT; + this->width = 0; + this->height = 0; + + this->redraw_region = NULL; + this->current_item = NULL; + this->new_current_item = NULL; + this->grabbed_item = NULL; + this->focused_item = NULL; + this->pixmap_gc = NULL; + + this->pick_event.type = GDK_LEAVE_NOTIFY; + this->pick_event.crossing.x = 0; + this->pick_event.crossing.y = 0; + + this->scroll_x1 = 0.0; + this->scroll_y1 = 0.0; + this->scroll_x2 = canvas->layout.width; + this->scroll_y2 = canvas->layout.height; + + this->pixels_per_unit = 1.0; + this->font_size = ganv_canvas_get_default_font_size(canvas); + + this->idle_id = 0; + this->root_destroy_id = g_signal_connect( + this->root, "destroy", G_CALLBACK(panic_root_destroyed), canvas); + + this->redraw_x1 = 0; + this->redraw_y1 = 0; + this->redraw_x2 = 0; + this->redraw_y2 = 0; + + this->draw_xofs = 0; + this->draw_yofs = 0; + this->zoom_xofs = 0; + this->zoom_yofs = 0; + + this->state = 0; + this->grabbed_event_mask = 0; + + this->center_scroll_region = TRUE; + this->need_update = FALSE; + this->need_redraw = FALSE; + this->need_repick = TRUE; + this->left_grabbed_item = FALSE; + this->in_repick = FALSE; + this->locked = FALSE; + +#ifdef GANV_FDGL + this->layout_idle_id = 0; +#endif + + _animate_idle_id = g_timeout_add(120, on_animate_timeout, this); + + gtk_layout_set_hadjustment(GTK_LAYOUT(canvas), NULL); + gtk_layout_set_vadjustment(GTK_LAYOUT(canvas), NULL); + _wrapper_key = g_quark_from_string("ganvmm"); _move_cursor = gdk_cursor_new(GDK_FLEUR); - - g_signal_connect(G_OBJECT(ganv_canvas_root(GANV_CANVAS(_gcanvas))), - "event", G_CALLBACK(on_canvas_event), this); } ~GanvCanvasImpl() { + while (g_idle_remove_by_data(this)) ; + ganv_canvas_clear(_gcanvas); gdk_cursor_unref(_move_cursor); } - static gboolean - on_canvas_event(GanvItem* canvasitem, - GdkEvent* ev, - void* impl) - { - return ((GanvCanvasImpl*)impl)->on_event(ev); - } + static gboolean on_animate_timeout(gpointer impl); #ifdef GANV_FDGL static gboolean on_layout_timeout(gpointer impl) { @@ -226,52 +277,19 @@ struct GanvCanvasImpl { } static void on_layout_done(gpointer impl) { - ((GanvCanvasImpl*)impl)->_layout_idle_id = 0; + ((GanvCanvasImpl*)impl)->layout_idle_id = 0; } gboolean layout_iteration(); gboolean layout_calculate(double dur, bool update); - #endif - GanvItem* root() { - return ganv_canvas_root(GANV_CANVAS(_gcanvas)); - } - - void resize(double width, double height); - void contents_changed(); - - void set_zoom_and_font_size(double zoom, double points); - - void for_each_node(GanvNodeFunc f, void* data); - void for_each_edge_from(const GanvNode* tail, GanvEdgeFunc f, void* data); - void for_each_edge_to(const GanvNode* head, GanvEdgeFunc f, void* data); - void for_each_edge_on(const GanvNode* node, GanvEdgeFunc f, void* data); - - void add_item(GanvNode* i); - bool remove_item(GanvNode* i); - - void select_edge(GanvEdge* edge); - void unselect_edge(GanvEdge* edge); - void select_item(GanvNode* item); - void unselect_item(GanvNode* item); void unselect_ports(); - void clear_selection(); - - void move_selected_items(double dx, double dy); - void selection_move_finished(); #if defined(HAVE_AGRAPH_2_20) || defined(HAVE_AGRAPH_2_30) GVNodes layout_dot(const std::string& filename); #endif - void remove_edge(GanvEdge* c); - bool are_connected(const GanvNode* tail, - const GanvNode* head) const; - GanvEdge* - get_edge_between(const GanvNode* tail, - const GanvNode* head) const; - typedef std::set<GanvEdge*, TailHeadOrder> Edges; typedef std::set<GanvEdge*, HeadTailOrder> DstEdges; typedef std::set<GanvEdge*> SelectedEdges; @@ -296,21 +314,19 @@ struct GanvCanvasImpl { void end_connect_drag(); /* - Event handler for ports. + Event handler for ports. - This must be implemented as a Canvas method since port event handling - depends on shared data (for selection and connecting). This function - should only be used by Port implementations. + This must be implemented as a Canvas method since port event handling + depends on shared data (for selection and connecting). This function + should only be used by Port implementations. */ bool port_event(GdkEvent* event, GanvPort* port); void ports_joined(GanvPort* port1, GanvPort* port2); - bool animate_selected(); void move_contents_to_internal(double x, double y, double min_x, double min_y); GanvCanvas* _gcanvas; - GtkLayout* _layout; Items _items; ///< Items on this canvas Edges _edges; ///< Edges ordered (src, dst) @@ -328,15 +344,112 @@ struct GanvCanvasImpl { double _select_start_x; ///< Selection drag start x coordinate double _select_start_y; ///< Selection drag start y coordinate - double _zoom; ///< Current zoom level - double _font_size; ///< Current font size in points - enum DragState { NOT_DRAGGING, EDGE, SCROLL, SELECT }; DragState _drag_state; GQuark _wrapper_key; GdkCursor* _move_cursor; - guint _layout_idle_id; + guint _animate_idle_id; + + /* Root canvas item */ + GanvItem* root; + + /* Flow direction */ + GanvDirection direction; + + /* Canvas width */ + double width; + + /* Canvas height */ + double height; + + /* Region that needs redrawing (list of rectangles) */ + GSList* redraw_region; + + /* The item containing the mouse pointer, or NULL if none */ + GanvItem* current_item; + + /* Item that is about to become current (used to track deletions and such) */ + GanvItem* new_current_item; + + /* Item that holds a pointer grab, or NULL if none */ + GanvItem* grabbed_item; + + /* If non-NULL, the currently focused item */ + GanvItem* focused_item; + + /* GC for temporary draw pixmap */ + GdkGC* pixmap_gc; + + /* Event on which selection of current item is based */ + GdkEvent pick_event; + + /* Scrolling region */ + double scroll_x1; + double scroll_y1; + double scroll_x2; + double scroll_y2; + + /* Scaling factor to be used for display */ + double pixels_per_unit; + + /* Font size in points */ + double font_size; + + /* Idle handler ID */ + guint idle_id; + + /* Signal handler ID for destruction of the root item */ + guint root_destroy_id; + + /* Area that is being redrawn. Contains (x1, y1) but not (x2, y2). + * Specified in canvas pixel coordinates. + */ + int redraw_x1; + int redraw_y1; + int redraw_x2; + int redraw_y2; + + /* Offsets of the temprary drawing pixmap */ + int draw_xofs; + int draw_yofs; + + /* Internal pixel offsets when zoomed out */ + int zoom_xofs; + int zoom_yofs; + + /* Last known modifier state, for deferred repick when a button is down */ + int state; + + /* Event mask specified when grabbing an item */ + guint grabbed_event_mask; + + /* Whether the canvas should center the scroll region in the middle of + * the window if the scroll region is smaller than the window. + */ + gboolean center_scroll_region; + + /* Whether items need update at next idle loop iteration */ + gboolean need_update; + + /* Whether the canvas needs redrawing at the next idle loop iteration */ + gboolean need_redraw; + + /* Whether current item will be repicked at next idle loop iteration */ + gboolean need_repick; + + /* For use by internal pick_current_item() function */ + gboolean left_grabbed_item; + + /* For use by internal pick_current_item() function */ + gboolean in_repick; + + /* Disable changes to canvas */ + gboolean locked; + +#ifdef GANV_FDGL + guint layout_idle_id; +#endif }; typedef struct { @@ -372,38 +485,6 @@ GanvCanvasImpl::first_edge_to(const GanvNode* head) return _dst_edges.lower_bound((GanvEdge*)&key); } -void -GanvCanvasImpl::select_edge(GanvEdge* edge) -{ - ganv_item_set(GANV_ITEM(edge), "selected", TRUE, NULL); - _selected_edges.insert(edge); -} - -void -GanvCanvasImpl::unselect_edge(GanvEdge* edge) -{ - ganv_item_set(GANV_ITEM(edge), "selected", FALSE, NULL); - _selected_edges.erase(edge); -} - -void -GanvCanvasImpl::move_selected_items(double dx, double dy) -{ - FOREACH_ITEM(_selected_items, i) { - ganv_node_move(*i, dx, dy); - } -} - -void -GanvCanvasImpl::selection_move_finished() -{ - FOREACH_ITEM(_selected_items, i) { - const double x = GANV_ITEM(*i)->x; - const double y = GANV_ITEM(*i)->y; - g_signal_emit(*i, signal_moved, 0, x, y, NULL); - } -} - static void select_if_tail_is_selected(GanvEdge* edge, void* data) { @@ -441,110 +522,16 @@ select_edges(GanvPort* port, void* data) { GanvCanvasImpl* impl = (GanvCanvasImpl*)data; if (port->impl->is_input) { - impl->for_each_edge_to(GANV_NODE(port), - select_if_tail_is_selected, - NULL); - } else { - impl->for_each_edge_from(GANV_NODE(port), - select_if_head_is_selected, - NULL); - } -} - -void -GanvCanvasImpl::add_item(GanvNode* n) -{ - GanvItem* item = GANV_ITEM(n); - if (item->parent == GANV_ITEM(root())) { - _items.insert(n); - } -} - -/** Remove an item from the canvas, cutting all references. - * Returns true if item was found (and removed). - */ -bool -GanvCanvasImpl::remove_item(GanvNode* item) -{ - bool ret = false; - - if (item == (GanvNode*)_connect_port) { - if (_drag_state == EDGE) { - ganv_item_ungrab(GANV_ITEM(root()), 0); - end_connect_drag(); - } - _connect_port = NULL; - } - - // Remove from selection - _selected_items.erase(item); - - // Remove children ports from selection if item is a module - if (GANV_IS_MODULE(item)) { - GanvModule* const module = GANV_MODULE(item); - for (unsigned i = 0; i < ganv_module_num_ports(module); ++i) { - unselect_port(ganv_module_get_port(module, i)); - } - } - - // Remove from items - _items.erase(item); - - return ret; -} - -static void -select_if_ends_are_selected(GanvEdge* edge, void* data) -{ - if (ganv_node_is_selected(ganv_edge_get_tail(edge)) && - ganv_node_is_selected(ganv_edge_get_head(edge))) { - ganv_edge_select(edge); - } -} - -void -GanvCanvasImpl::select_item(GanvNode* m) -{ - _selected_items.insert(m); - - // Select any connections to or from this node - if (GANV_IS_MODULE(m)) { - ganv_module_for_each_port(GANV_MODULE(m), select_edges, this); - } else { - for_each_edge_on(m, select_if_ends_are_selected, this); - } - - g_object_set(m, "selected", TRUE, NULL); -} - -static void -unselect_edges(GanvPort* port, void* data) -{ - GanvCanvasImpl* impl = (GanvCanvasImpl*)data; - if (port->impl->is_input) { - impl->for_each_edge_to(GANV_NODE(port), - (GanvEdgeFunc)ganv_edge_unselect, - NULL); - } else { - impl->for_each_edge_from(GANV_NODE(port), - (GanvEdgeFunc)ganv_edge_unselect, - NULL); - } -} - -void -GanvCanvasImpl::unselect_item(GanvNode* m) -{ - // Unselect any connections to or from this node - if (GANV_IS_MODULE(m)) { - ganv_module_for_each_port(GANV_MODULE(m), unselect_edges, this); + ganv_canvas_for_each_edge_to(impl->_gcanvas, + GANV_NODE(port), + select_if_tail_is_selected, + NULL); } else { - for_each_edge_on(m, (GanvEdgeFunc)ganv_edge_unselect, NULL); + ganv_canvas_for_each_edge_from(impl->_gcanvas, + GANV_NODE(port), + select_if_head_is_selected, + NULL); } - - // Unselect item - _selected_items.erase(m); - g_object_set(m, "selected", FALSE, NULL); } #if defined(HAVE_AGRAPH_2_20) || defined(HAVE_AGRAPH_2_30) @@ -586,7 +573,7 @@ GanvCanvasImpl::layout_dot(const std::string& filename) nodes.gvc = gvc; nodes.G = G; - const bool flow_right = _gcanvas->direction; + const bool flow_right = _gcanvas->impl->direction; if (flow_right) { agattr(G, AGRAPH, (char*)"rankdir", (char*)"LR"); } else { @@ -834,7 +821,7 @@ GanvCanvasImpl::layout_calculate(double dur, bool update) // A light directional force to push sources to the top left static const double DIR_MAGNITUDE = -1000.0; Vector dir = { 0.0, 0.0 }; - switch (_gcanvas->direction) { + switch (_gcanvas->impl->direction) { case GANV_DIRECTION_RIGHT: dir.x = DIR_MAGNITUDE; break; case GANV_DIRECTION_DOWN: dir.y = DIR_MAGNITUDE; break; } @@ -941,7 +928,7 @@ GanvCanvasImpl::layout_calculate(double dur, bool update) if (update) { ganv_item_request_update(item); - item->canvas->need_repick = TRUE; + item->canvas->impl->need_repick = TRUE; } if (lrint(x0) != lrint(item->x) || lrint(y0) != lrint(item->y)) { @@ -969,41 +956,6 @@ GanvCanvasImpl::layout_calculate(double dur, bool update) #endif // GANV_FDGL void -GanvCanvasImpl::remove_edge(GanvEdge* edge) -{ - if (edge) { - _selected_edges.erase(edge); - _edges.erase(edge); - _dst_edges.erase(edge); - ganv_edge_request_redraw(GANV_ITEM(edge)->canvas, &edge->impl->coords); - gtk_object_destroy(GTK_OBJECT(edge)); - contents_changed(); - } -} - -GanvEdge* -GanvCanvasImpl::get_edge_between(const GanvNode* tail, - const GanvNode* head) const -{ - GanvEdgeKey key; - make_edge_search_key(&key, tail, head); - Edges::const_iterator i = _edges.find((GanvEdge*)&key); - return (i != _edges.end()) ? *i : NULL; -} - -/** Return whether there is a edge between item1 and item2. - * - * Note that edges are directed, so this may return false when there - * is a edge between the two items (in the opposite direction). - */ -bool -GanvCanvasImpl::are_connected(const GanvNode* tail, - const GanvNode* head) const -{ - return get_edge_between(tail, head) != NULL; -} - -void GanvCanvasImpl::select_port(GanvPort* p, bool unique) { if (unique) { @@ -1085,8 +1037,8 @@ GanvCanvasImpl::selection_joined_with(GanvPort* port) void GanvCanvasImpl::join_selection() { - vector<GanvPort*> inputs; - vector<GanvPort*> outputs; + std::vector<GanvPort*> inputs; + std::vector<GanvPort*> outputs; FOREACH_SELECTED_PORT(i) { if ((*i)->impl->is_input) { inputs.push_back(*i); @@ -1151,7 +1103,7 @@ GanvCanvasImpl::on_event(GdkEvent* event) case GDK_Return: if (_selected_ports.size() > 1) { join_selection(); - clear_selection(); + ganv_canvas_clear_selection(_gcanvas); } break; default: @@ -1199,9 +1151,11 @@ GanvCanvasImpl::scroll_drag_handler(GdkEvent* event) static double last_x = 0; static double last_y = 0; + GanvItem* root = ganv_canvas_root(_gcanvas); + if (event->type == GDK_BUTTON_PRESS && event->button.button == 2) { - ganv_item_grab( - GANV_ITEM(root()), + ganv_canvas_grab_item( + root, GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK, NULL, event->button.time); ganv_canvas_get_scroll_offsets(GANV_CANVAS(_gcanvas), &original_scroll_x, &original_scroll_y); @@ -1226,12 +1180,12 @@ GanvCanvasImpl::scroll_drag_handler(GdkEvent* event) scroll_offset_x += x_offset; scroll_offset_y += y_offset; ganv_canvas_scroll_to(GANV_CANVAS(_gcanvas), - lrint(original_scroll_x + scroll_offset_x), - lrint(original_scroll_y + scroll_offset_y)); + lrint(original_scroll_x + scroll_offset_x), + lrint(original_scroll_y + scroll_offset_y)); last_x = x; last_y = y; } else if (event->type == GDK_BUTTON_RELEASE && _drag_state == SCROLL) { - ganv_item_ungrab(GANV_ITEM(root()), event->button.time); + ganv_canvas_ungrab_item(root, event->button.time); _drag_state = NOT_DRAGGING; } else { handled = false; @@ -1259,14 +1213,15 @@ get_motion_coords(GdkEventMotion* motion, double* x, double* y) bool GanvCanvasImpl::select_drag_handler(GdkEvent* event) { + GanvItem* root = ganv_canvas_root(_gcanvas); if (event->type == GDK_BUTTON_PRESS && event->button.button == 1) { assert(_select_rect == NULL); _drag_state = SELECT; if ( !(event->button.state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK)) ) - clear_selection(); + ganv_canvas_clear_selection(_gcanvas); _select_rect = GANV_BOX( ganv_item_new( - GANV_ITEM(root()), + root, ganv_box_get_type(), "x1", event->button.x, "y1", event->button.y, @@ -1277,8 +1232,8 @@ GanvCanvasImpl::select_drag_handler(GdkEvent* event) NULL)); _select_start_x = event->button.x; _select_start_y = event->button.y; - ganv_item_grab( - GANV_ITEM(root()), GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK, + ganv_canvas_grab_item( + root, GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK, NULL, event->button.time); return true; } else if (event->type == GDK_MOTION_NOTIFY && _drag_state == SELECT) { @@ -1308,9 +1263,9 @@ GanvCanvasImpl::select_drag_handler(GdkEvent* event) gboolean selected; g_object_get(G_OBJECT(node), "selected", &selected, NULL); if (selected) { - unselect_item(node); + ganv_canvas_unselect_node(_gcanvas, node); } else { - select_item(node); + ganv_canvas_select_node(_gcanvas, node); } } } @@ -1323,11 +1278,11 @@ GanvCanvasImpl::select_drag_handler(GdkEvent* event) ganv_box_get_y1(_select_rect), ganv_box_get_x2(_select_rect), ganv_box_get_y2(_select_rect))) { - select_edge(*i); + ganv_canvas_select_edge(_gcanvas, *i); } } - ganv_item_ungrab(GANV_ITEM(root()), event->button.time); + ganv_canvas_ungrab_item(root, event->button.time); gtk_object_destroy(GTK_OBJECT(_select_rect)); _select_rect = NULL; @@ -1392,7 +1347,7 @@ GanvCanvasImpl::connect_drag_handler(GdkEvent* event) return true; } else if (event->type == GDK_BUTTON_RELEASE) { - ganv_item_ungrab(GANV_ITEM(root()), event->button.time); + ganv_canvas_ungrab_item(root, event->button.time); double x = event->button.x; double y = event->button.y; @@ -1473,23 +1428,25 @@ GanvCanvasImpl::port_event(GdkEvent* event, GanvPort* port) control_start_x = event->button.x_root; control_start_y = event->button.y_root; control_start_value = ganv_port_get_control_value(port); - ganv_item_grab(GANV_ITEM(port), - GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK, - NULL, event->button.time); + ganv_canvas_grab_item( + GANV_ITEM(port), + GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK, + NULL, event->button.time); GANV_NODE(port)->impl->grabbed = TRUE; } } else if (!port->impl->is_input) { port_dragging = port_pressed = true; - ganv_item_grab(GANV_ITEM(port), - GDK_BUTTON_RELEASE_MASK|GDK_POINTER_MOTION_MASK| - GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK, - NULL, event->button.time); + ganv_canvas_grab_item( + GANV_ITEM(port), + GDK_BUTTON_RELEASE_MASK|GDK_POINTER_MOTION_MASK| + GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK, + NULL, event->button.time); } else { port_pressed = true; - ganv_item_grab(GANV_ITEM(port), - GDK_BUTTON_RELEASE_MASK, - NULL, event->button.time); + ganv_canvas_grab_item(GANV_ITEM(port), + GDK_BUTTON_RELEASE_MASK, + NULL, event->button.time); } return true; } @@ -1540,7 +1497,7 @@ GanvCanvasImpl::port_event(GdkEvent* event, GanvPort* port) case GDK_BUTTON_RELEASE: if (port_pressed) { - ganv_item_ungrab(GANV_ITEM(port), event->button.time); + ganv_canvas_ungrab_item(GANV_ITEM(port), event->button.time); } if (port_dragging) { @@ -1585,9 +1542,9 @@ GanvCanvasImpl::port_event(GdkEvent* event, GanvPort* port) _drag_state = GanvCanvasImpl::EDGE; _connect_port = port; port_dragging = false; - ganv_item_ungrab(GANV_ITEM(port), event->crossing.time); - ganv_item_grab( - GANV_ITEM(root()), + ganv_canvas_ungrab_item(GANV_ITEM(port), event->crossing.time); + ganv_canvas_grab_item( + root, GDK_BUTTON_PRESS_MASK|GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK, NULL, event->crossing.time); return true; @@ -1629,7 +1586,7 @@ GanvCanvasImpl::ports_joined(GanvPort* port1, GanvPort* port2) return; } - if (!are_connected(src_node, dst_node)) { + if (!ganv_canvas_get_edge(_gcanvas, src_node, dst_node)) { g_signal_emit(_gcanvas, signal_connect, 0, src_node, dst_node, NULL); } else { @@ -1639,9 +1596,11 @@ GanvCanvasImpl::ports_joined(GanvPort* port1, GanvPort* port2) } /** Update animated "rubber band" selection effect. */ -bool -GanvCanvasImpl::animate_selected() +gboolean +GanvCanvasImpl::on_animate_timeout(gpointer data) { + GanvCanvasImpl* impl = (GanvCanvasImpl*)data; + #ifdef g_get_monotonic_time // Only available in glib 2.28 const double seconds = g_get_monotonic_time() / 1000000.0; @@ -1651,19 +1610,21 @@ GanvCanvasImpl::animate_selected() const double seconds = time.tv_sec + time.tv_usec / (double)G_USEC_PER_SEC; #endif - FOREACH_ITEM(_selected_items, s) { + FOREACH_ITEM(impl->_selected_items, s) { ganv_node_tick(*s, seconds); } - FOREACH_SELECTED_PORT(p) { + for (SelectedPorts::iterator p = impl->_selected_ports.begin(); + p != impl->_selected_ports.end(); + ++p) { ganv_node_tick(GANV_NODE(*p), seconds); } - FOREACH_EDGE(_selected_edges, c) { + FOREACH_EDGE(impl->_selected_edges, c) { ganv_edge_tick(*c, seconds); } - return true; + return TRUE; } void @@ -1677,52 +1638,6 @@ GanvCanvasImpl::move_contents_to_internal(double x, double y, double min_x, doub } void -GanvCanvasImpl::for_each_node(GanvNodeFunc f, - void* data) -{ - FOREACH_ITEM(_items, i) { - f(*i, data); - } -} - -void -GanvCanvasImpl::for_each_edge_from(const GanvNode* tail, - GanvEdgeFunc f, - void* data) -{ - for (GanvCanvasImpl::Edges::const_iterator i = first_edge_from(tail); - i != _edges.end() && (*i)->impl->tail == tail;) { - GanvCanvasImpl::Edges::const_iterator next = i; - ++next; - f((*i), data); - i = next; - } -} - -void -GanvCanvasImpl::for_each_edge_to(const GanvNode* head, - GanvEdgeFunc f, - void* data) -{ - for (GanvCanvasImpl::Edges::const_iterator i = first_edge_to(head); - i != _dst_edges.end() && (*i)->impl->head == head;) { - GanvCanvasImpl::Edges::const_iterator next = i; - ++next; - f((*i), data); - i = next; - } -} - -void -GanvCanvasImpl::for_each_edge_on(const GanvNode* node, - GanvEdgeFunc f, - void* data) -{ - for_each_edge_from(node, f, data); - for_each_edge_to(node, f, data); -} - -void GanvCanvasImpl::unselect_ports() { for (GanvCanvasImpl::SelectedPorts::iterator i = _selected_ports.begin(); @@ -1733,70 +1648,6 @@ GanvCanvasImpl::unselect_ports() _last_selected_port = NULL; } -void -GanvCanvasImpl::clear_selection() -{ - unselect_ports(); - - Items items(_selected_items); - _selected_items.clear(); - FOREACH_ITEM(items, i) { - ganv_item_set(GANV_ITEM(*i), "selected", FALSE, NULL); - } - - SelectedEdges edges(_selected_edges); - FOREACH_SELECTED_EDGE(edges, c) { - ganv_item_set(GANV_ITEM(*c), "selected", FALSE, NULL); - } -} - -void -GanvCanvasImpl::resize(double width, double height) -{ - if (width != _gcanvas->width || height != _gcanvas->height) { - _gcanvas->width = width; - _gcanvas->height = height; - ganv_canvas_set_scroll_region(GANV_CANVAS(_gcanvas), - 0.0, 0.0, width, height); - } -} - -void -GanvCanvasImpl::contents_changed() -{ -#ifdef GANV_FDGL - if (!_layout_idle_id) { - _layout_idle_id = g_timeout_add_full( - G_PRIORITY_DEFAULT_IDLE, - 33, - on_layout_timeout, - this, - on_layout_done); - } -#endif -} - -void -GanvCanvasImpl::set_zoom_and_font_size(double zoom, double points) -{ - points = std::max(points, 1.0); - zoom = std::max(zoom, 0.01); - - if (zoom == _zoom && points == _font_size) - return; - - if (zoom != _zoom) { - _zoom = zoom; - ganv_canvas_set_pixels_per_unit(GANV_CANVAS(_gcanvas), zoom); - } - - _font_size = points; - - FOREACH_ITEM(_items, i) { - ganv_node_redraw_text(*i); - } -} - namespace Ganv { static gboolean @@ -1824,45 +1675,40 @@ on_disconnect(GanvCanvas* canvas, GanvNode* tail, GanvNode* head, void* data) Canvas::Canvas(double width, double height) : _gobj(GANV_CANVAS(ganv_canvas_new(width, height))) { - g_object_set_qdata(G_OBJECT(impl()->_gcanvas), wrapper_key(), this); + g_object_set_qdata(G_OBJECT(_gobj->impl->_gcanvas), wrapper_key(), this); - g_signal_connect_after(impl()->root(), "event", + g_signal_connect_after(ganv_canvas_root(_gobj), "event", G_CALLBACK(on_event_after), this); g_signal_connect(gobj(), "connect", G_CALLBACK(on_connect), this); g_signal_connect(gobj(), "disconnect", G_CALLBACK(on_disconnect), this); - - _animate_connection = Glib::signal_timeout().connect( - sigc::mem_fun(impl(), &GanvCanvasImpl::animate_selected), 120); } Canvas::~Canvas() { - _animate_connection.disconnect(); - clear(); - delete impl(); + delete _gobj->impl; } void Canvas::remove_edge(Node* item1, Node* item2) { - Edge* edge = get_edge(item1, item2); + GanvEdge* edge = ganv_canvas_get_edge(_gobj, item1->gobj(), item2->gobj()); if (edge) { - impl()->remove_edge(edge->gobj()); + ganv_canvas_remove_edge(_gobj, edge); } } void Canvas::remove_edge(Edge* edge) { - impl()->remove_edge(edge->gobj()); + ganv_canvas_remove_edge(_gobj, edge->gobj()); } Edge* Canvas::get_edge(Node* tail, Node* head) const { - GanvEdge* e = impl()->get_edge_between(tail->gobj(), head->gobj()); + GanvEdge* e = ganv_canvas_get_edge(_gobj, tail->gobj(), head->gobj()); if (e) { return Glib::wrap(e); } else { @@ -1870,68 +1716,10 @@ Canvas::get_edge(Node* tail, Node* head) const } } -void -Canvas::for_each_edge(GanvEdgeFunc f, void* data) -{ - for (GanvCanvasImpl::Edges::iterator i = impl()->_edges.begin(); - i != impl()->_edges.end();) { - GanvCanvasImpl::Edges::iterator next = i; - ++next; - - f((*i), data); - - i = next; - } -} - -void -Canvas::for_each_selected_edge(GanvEdgeFunc f, void* data) -{ - FOREACH_EDGE(impl()->_selected_edges, i) { - f((*i), data); - } -} - -GanvItem* -Canvas::root() -{ - return ganv_canvas_root(GANV_CANVAS(impl()->_gcanvas)); -} - -Gtk::Layout& -Canvas::widget() -{ - return *Glib::wrap(impl()->_layout); -} - -void -Canvas::get_scroll_offsets(int& cx, int& cy) const -{ - ganv_canvas_get_scroll_offsets(GANV_CANVAS(impl()->_gcanvas), &cx, &cy); -} - -void -Canvas::scroll_to(int x, int y) -{ - ganv_canvas_scroll_to(GANV_CANVAS(impl()->_gcanvas), x, y); -} - GQuark Canvas::wrapper_key() { - return impl()->_wrapper_key; -} - -GanvCanvas* -Canvas::gobj() -{ - return impl()->_gcanvas; -} - -const GanvCanvas* -Canvas::gobj() const -{ - return impl()->_gcanvas; + return _gobj->impl->_wrapper_key; } } // namespace Ganv @@ -1956,13 +1744,12 @@ enum { PROP_FOCUSED_ITEM }; -/* Callback used when the root item of a canvas is destroyed. The user should - * never ever do this, so we panic if this happens. - */ -static void -panic_root_destroyed(GtkObject* object, gpointer data) +static gboolean +on_canvas_event(GanvItem* canvasitem, + GdkEvent* ev, + void* impl) { - g_error("Eeeek, root item %p of canvas %p was destroyed!", (void*)object, data); + return ((GanvCanvasImpl*)impl)->on_event(ev); } static void @@ -1970,44 +1757,10 @@ ganv_canvas_init(GanvCanvas* canvas) { GTK_WIDGET_SET_FLAGS(canvas, GTK_CAN_FOCUS); - canvas->need_update = FALSE; - canvas->need_redraw = FALSE; - canvas->redraw_region = NULL; - canvas->idle_id = 0; - - canvas->scroll_x1 = 0.0; - canvas->scroll_y1 = 0.0; - canvas->scroll_x2 = canvas->layout.width; - canvas->scroll_y2 = canvas->layout.height; - - canvas->pixels_per_unit = 1.0; - - canvas->pick_event.type = GDK_LEAVE_NOTIFY; - canvas->pick_event.crossing.x = 0; - canvas->pick_event.crossing.y = 0; - - canvas->center_scroll_region = TRUE; - - gtk_layout_set_hadjustment(GTK_LAYOUT(canvas), NULL); - gtk_layout_set_vadjustment(GTK_LAYOUT(canvas), NULL); - - /* Create the root item as a special case */ - canvas->root = GANV_ITEM(g_object_new(ganv_group_get_type(), NULL)); - canvas->root->canvas = canvas; - - g_object_ref_sink(canvas->root); - - canvas->root_destroy_id = g_signal_connect(canvas->root, "destroy", - G_CALLBACK(panic_root_destroyed), - canvas); - - canvas->need_repick = TRUE; - - /*************************/ - - canvas->direction = GANV_DIRECTION_RIGHT; canvas->impl = new GanvCanvasImpl(canvas); - canvas->impl->_font_size = ganv_canvas_get_default_font_size(canvas); + + g_signal_connect(G_OBJECT(ganv_canvas_root(GANV_CANVAS(canvas))), + "event", G_CALLBACK(on_canvas_event), canvas->impl); } static void @@ -2023,10 +1776,10 @@ ganv_canvas_set_property(GObject* object, switch (prop_id) { case PROP_WIDTH: - ganv_canvas_resize(canvas, g_value_get_double(value), canvas->height); + ganv_canvas_resize(canvas, g_value_get_double(value), canvas->impl->height); break; case PROP_HEIGHT: - ganv_canvas_resize(canvas, canvas->width, g_value_get_double(value)); + ganv_canvas_resize(canvas, canvas->impl->width, g_value_get_double(value)); break; case PROP_DIRECTION: ganv_canvas_set_direction(canvas, (GanvDirection)g_value_get_enum(value)); @@ -2035,10 +1788,10 @@ ganv_canvas_set_property(GObject* object, ganv_canvas_set_font_size(canvas, g_value_get_double(value)); break; case PROP_LOCKED: - canvas->locked = g_value_get_boolean(value); + canvas->impl->locked = g_value_get_boolean(value); break; case PROP_FOCUSED_ITEM: - canvas->focused_item = GANV_ITEM(g_value_get_object(value)); + canvas->impl->focused_item = GANV_ITEM(g_value_get_object(value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); @@ -2058,11 +1811,11 @@ ganv_canvas_get_property(GObject* object, GanvCanvas* canvas = GANV_CANVAS(object); switch (prop_id) { - GET_CASE(WIDTH, double, canvas->width) - GET_CASE(HEIGHT, double, canvas->height) - GET_CASE(LOCKED, boolean, canvas->locked); + GET_CASE(WIDTH, double, canvas->impl->width) + GET_CASE(HEIGHT, double, canvas->impl->height) + GET_CASE(LOCKED, boolean, canvas->impl->locked); case PROP_FOCUSED_ITEM: - g_value_set_object(value, GANV_CANVAS(object)->focused_item); + g_value_set_object(value, GANV_CANVAS(object)->impl->focused_item); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); @@ -2101,8 +1854,6 @@ ganv_canvas_class_init(GanvCanvasClass* klass) widget_class->focus_out_event = ganv_canvas_focus_out; widget_class->scroll_event = ganv_canvas_scroll; - klass->request_update = ganv_canvas_request_update_real; - g_object_class_install_property( gobject_class, PROP_FOCUSED_ITEM, g_param_spec_object( "focused-item", @@ -2194,13 +1945,27 @@ ganv_canvas_class_init(GanvCanvasClass* klass) void ganv_canvas_resize(GanvCanvas* canvas, double width, double height) { - canvas->impl->resize(width, height); + if (width != canvas->impl->width || height != canvas->impl->height) { + canvas->impl->width = width; + canvas->impl->height = height; + ganv_canvas_set_scroll_region( + GANV_CANVAS(canvas), 0.0, 0.0, width, height); + } } void ganv_canvas_contents_changed(GanvCanvas* canvas) { - canvas->impl->contents_changed(); +#ifdef GANV_FDGL + if (!canvas->impl->layout_idle_id) { + canvas->impl->layout_idle_id = g_timeout_add_full( + G_PRIORITY_DEFAULT_IDLE, + 33, + GanvCanvasImpl::on_layout_timeout, + canvas->impl, + GanvCanvasImpl::on_layout_done); + } +#endif } /** @@ -2219,25 +1984,74 @@ ganv_canvas_get_default_font_size(const GanvCanvas* canvas) double ganv_canvas_get_font_size(const GanvCanvas* canvas) { - return canvas->impl->_font_size; + return canvas->impl->font_size; } +/** + * ganv_canvas_set_zoom: + * @canvas: A canvas. + * @zoom: The number of pixels that correspond to one canvas unit. + * + * The anchor point for zooming, i.e. the point that stays fixed and all others + * zoom inwards or outwards from it, depends on whether the canvas is set to + * center the scrolling region or not. You can control this using the + * ganv_canvas_set_center_scroll_region() function. If the canvas is set to + * center the scroll region, then the center of the canvas window is used as + * the anchor point for zooming. Otherwise, the upper-left corner of the + * canvas window is used as the anchor point. + */ void ganv_canvas_set_zoom(GanvCanvas* canvas, double zoom) { - canvas->impl->set_zoom_and_font_size(zoom, canvas->impl->_font_size); -} + g_return_if_fail(GANV_IS_CANVAS(canvas)); -void -ganv_canvas_set_font_size(GanvCanvas* canvas, double points) -{ - canvas->impl->set_zoom_and_font_size(canvas->impl->_zoom, points); + zoom = std::max(zoom, 0.01); + if (zoom == canvas->impl->pixels_per_unit) { + return; + } + + const int anchor_x = (canvas->impl->center_scroll_region) + ? GTK_WIDGET(canvas)->allocation.width / 2 + : 0; + const int anchor_y = (canvas->impl->center_scroll_region) + ? GTK_WIDGET(canvas)->allocation.height / 2 + : 0; + + /* Find the coordinates of the anchor point in units. */ + const double ax = (canvas->layout.hadjustment) + ? ((canvas->layout.hadjustment->value + anchor_x) + / canvas->impl->pixels_per_unit + + canvas->impl->scroll_x1 + canvas->impl->zoom_xofs) + : ((0.0 + anchor_x) / canvas->impl->pixels_per_unit + + canvas->impl->scroll_x1 + canvas->impl->zoom_xofs); + const double ay = (canvas->layout.hadjustment) + ? ((canvas->layout.vadjustment->value + anchor_y) + / canvas->impl->pixels_per_unit + + canvas->impl->scroll_y1 + canvas->impl->zoom_yofs) + : ((0.0 + anchor_y) / canvas->impl->pixels_per_unit + + canvas->impl->scroll_y1 + canvas->impl->zoom_yofs); + + /* Now calculate the new offset of the upper left corner. */ + const int x1 = ((ax - canvas->impl->scroll_x1) * zoom) - anchor_x; + const int y1 = ((ay - canvas->impl->scroll_y1) * zoom) - anchor_y; + + canvas->impl->pixels_per_unit = zoom; + ganv_canvas_scroll_to(canvas, x1, y1); + + ganv_canvas_request_update(canvas); + canvas->impl->need_repick = TRUE; } void -ganv_canvas_set_scale(GanvCanvas* canvas, double zoom, double points) +ganv_canvas_set_font_size(GanvCanvas* canvas, double points) { - canvas->impl->set_zoom_and_font_size(zoom, points); + points = std::max(points, 1.0); + if (points != canvas->impl->font_size) { + canvas->impl->font_size = points; + FOREACH_ITEM(canvas->impl->_items, i) { + ganv_node_redraw_text(*i); + } + } } void @@ -2285,11 +2099,11 @@ ganv_canvas_zoom_full(GanvCanvas* canvas) int scroll_x, scroll_y; ganv_canvas_w2c(GANV_CANVAS(canvas->impl->_gcanvas), - lrintf(left - pad), lrintf(bottom - pad), - &scroll_x, &scroll_y); + lrintf(left - pad), lrintf(bottom - pad), + &scroll_x, &scroll_y); ganv_canvas_scroll_to(GANV_CANVAS(canvas->impl->_gcanvas), - scroll_x, scroll_y); + scroll_x, scroll_y); } static void @@ -2300,11 +2114,17 @@ set_node_direction(GanvNode* node, void* data) } } +GanvDirection +ganv_canvas_get_direction(GanvCanvas* canvas) +{ + return canvas->impl->direction; +} + void ganv_canvas_set_direction(GanvCanvas* canvas, GanvDirection dir) { - if (canvas->direction != dir) { - canvas->direction = dir; + if (canvas->impl->direction != dir) { + canvas->impl->direction = dir; ganv_canvas_for_each_node(canvas, set_node_direction, &dir); ganv_canvas_contents_changed(canvas); } @@ -2313,7 +2133,18 @@ ganv_canvas_set_direction(GanvCanvas* canvas, GanvDirection dir) void ganv_canvas_clear_selection(GanvCanvas* canvas) { - canvas->impl->clear_selection(); + canvas->impl->unselect_ports(); + + Items items(canvas->impl->_selected_items); + canvas->impl->_selected_items.clear(); + FOREACH_ITEM(items, i) { + ganv_item_set(GANV_ITEM(*i), "selected", FALSE, NULL); + } + + GanvCanvasImpl::SelectedEdges edges(canvas->impl->_selected_edges); + FOREACH_SELECTED_EDGE(edges, c) { + ganv_item_set(GANV_ITEM(*c), "selected", FALSE, NULL); + } } void @@ -2321,34 +2152,116 @@ ganv_canvas_move_selected_items(GanvCanvas* canvas, double dx, double dy) { - return canvas->impl->move_selected_items(dx, dy); + FOREACH_ITEM(canvas->impl->_selected_items, i) { + ganv_node_move(*i, dx, dy); + } } void ganv_canvas_selection_move_finished(GanvCanvas* canvas) { - return canvas->impl->selection_move_finished(); + FOREACH_ITEM(canvas->impl->_selected_items, i) { + const double x = GANV_ITEM(*i)->x; + const double y = GANV_ITEM(*i)->y; + g_signal_emit(*i, signal_moved, 0, x, y, NULL); + } +} + +static void +select_if_ends_are_selected(GanvEdge* edge, void* data) +{ + if (ganv_node_is_selected(ganv_edge_get_tail(edge)) && + ganv_node_is_selected(ganv_edge_get_head(edge))) { + ganv_edge_select(edge); + } +} + +static void +unselect_edges(GanvPort* port, void* data) +{ + GanvCanvasImpl* impl = (GanvCanvasImpl*)data; + if (port->impl->is_input) { + ganv_canvas_for_each_edge_to(impl->_gcanvas, + GANV_NODE(port), + (GanvEdgeFunc)ganv_edge_unselect, + NULL); + } else { + ganv_canvas_for_each_edge_from(impl->_gcanvas, + GANV_NODE(port), + (GanvEdgeFunc)ganv_edge_unselect, + NULL); + } } void ganv_canvas_select_node(GanvCanvas* canvas, GanvNode* node) { - canvas->impl->select_item(node); + canvas->impl->_selected_items.insert(node); + + // Select any connections to or from this node + if (GANV_IS_MODULE(node)) { + ganv_module_for_each_port(GANV_MODULE(node), select_edges, canvas->impl); + } else { + ganv_canvas_for_each_edge_on( + canvas, node, select_if_ends_are_selected, canvas->impl); + } + + g_object_set(node, "selected", TRUE, NULL); } void ganv_canvas_unselect_node(GanvCanvas* canvas, GanvNode* node) { - canvas->impl->unselect_item(node); + // Unselect any connections to or from canvas->impl node + if (GANV_IS_MODULE(node)) { + ganv_module_for_each_port(GANV_MODULE(node), unselect_edges, canvas->impl); + } else { + ganv_canvas_for_each_edge_on( + canvas, node, (GanvEdgeFunc)ganv_edge_unselect, NULL); + } + + // Unselect item + canvas->impl->_selected_items.erase(node); + g_object_set(node, "selected", FALSE, NULL); } void ganv_canvas_add_node(GanvCanvas* canvas, GanvNode* node) { - canvas->impl->add_item(node); + GanvItem* item = GANV_ITEM(node); + if (item->parent == ganv_canvas_root(canvas)) { + canvas->impl->_items.insert(node); + } +} + +void +ganv_canvas_remove_node(GanvCanvas* canvas, + GanvNode* node) +{ + if (node == (GanvNode*)canvas->impl->_connect_port) { + if (canvas->impl->_drag_state == GanvCanvasImpl::EDGE) { + ganv_canvas_ungrab_item(ganv_canvas_root(canvas), 0); + canvas->impl->end_connect_drag(); + } + canvas->impl->_connect_port = NULL; + } + + // Remove from selection + canvas->impl->_selected_items.erase(node); + + // Remove children ports from selection if item is a module + if (GANV_IS_MODULE(node)) { + GanvModule* const module = GANV_MODULE(node); + for (unsigned i = 0; i < ganv_module_num_ports(module); ++i) { + canvas->impl->unselect_port(ganv_module_get_port(module, i)); + } + } + + // Remove from items + canvas->impl->_items.erase(node); } /** @@ -2362,7 +2275,10 @@ ganv_canvas_get_edge(GanvCanvas* canvas, GanvNode* tail, GanvNode* head) { - return canvas->impl->get_edge_between(tail, head); + GanvEdgeKey key; + make_edge_search_key(&key, tail, head); + GanvCanvasImpl::Edges::const_iterator i = canvas->impl->_edges.find((GanvEdge*)&key); + return (i != canvas->impl->_edges.end()) ? *i : NULL; } void @@ -2370,7 +2286,7 @@ ganv_canvas_remove_edge_between(GanvCanvas* canvas, GanvNode* tail, GanvNode* head) { - canvas->impl->remove_edge(canvas->impl->get_edge_between(tail, head)); + ganv_canvas_remove_edge(canvas, ganv_canvas_get_edge(canvas, tail, head)); } void @@ -2382,40 +2298,42 @@ ganv_canvas_disconnect_edge(GanvCanvas* canvas, } void -ganv_canvas_remove_node(GanvCanvas* canvas, - GanvNode* node) -{ - canvas->impl->remove_item(node); -} - -void ganv_canvas_add_edge(GanvCanvas* canvas, GanvEdge* edge) { canvas->impl->_edges.insert(edge); canvas->impl->_dst_edges.insert(edge); - canvas->impl->contents_changed(); + ganv_canvas_contents_changed(canvas); } void ganv_canvas_remove_edge(GanvCanvas* canvas, GanvEdge* edge) { - canvas->impl->remove_edge(edge); + if (edge) { + canvas->impl->_selected_edges.erase(edge); + canvas->impl->_edges.erase(edge); + canvas->impl->_dst_edges.erase(edge); + ganv_edge_request_redraw(GANV_ITEM(edge)->canvas, &edge->impl->coords); + gtk_object_destroy(GTK_OBJECT(edge)); + ganv_canvas_contents_changed(canvas); + } } void ganv_canvas_select_edge(GanvCanvas* canvas, GanvEdge* edge) { - canvas->impl->select_edge(edge); + ganv_item_set(GANV_ITEM(edge), "selected", TRUE, NULL); + canvas->impl->_selected_edges.insert(edge); } void ganv_canvas_unselect_edge(GanvCanvas* canvas, GanvEdge* edge) { - canvas->impl->unselect_edge(edge); + ganv_item_set(GANV_ITEM(edge), "selected", FALSE, NULL); + canvas->impl->_selected_edges.erase(edge); } void @@ -2423,7 +2341,9 @@ ganv_canvas_for_each_node(GanvCanvas* canvas, GanvNodeFunc f, void* data) { - canvas->impl->for_each_node(f, data); + FOREACH_ITEM(canvas->impl->_items, i) { + f(*i, data); + } } void @@ -2443,12 +2363,35 @@ ganv_canvas_empty(const GanvCanvas* canvas) } void +ganv_canvas_for_each_edge(GanvCanvas* canvas, + GanvEdgeFunc f, + void* data) +{ + GanvCanvasImpl* impl = canvas->impl; + for (GanvCanvasImpl::Edges::const_iterator i = impl->_edges.begin(); + i != impl->_edges.end(); + ++i) { + GanvCanvasImpl::Edges::const_iterator next = i; + ++next; + f((*i), data); + i = next; + } +} + +void ganv_canvas_for_each_edge_from(GanvCanvas* canvas, const GanvNode* tail, GanvEdgeFunc f, void* data) { - canvas->impl->for_each_edge_from(tail, f, data); + GanvCanvasImpl* impl = canvas->impl; + for (GanvCanvasImpl::Edges::const_iterator i = impl->first_edge_from(tail); + i != impl->_edges.end() && (*i)->impl->tail == tail;) { + GanvCanvasImpl::Edges::const_iterator next = i; + ++next; + f((*i), data); + i = next; + } } void @@ -2457,7 +2400,14 @@ ganv_canvas_for_each_edge_to(GanvCanvas* canvas, GanvEdgeFunc f, void* data) { - canvas->impl->for_each_edge_to(head, f, data); + GanvCanvasImpl* impl = canvas->impl; + for (GanvCanvasImpl::Edges::const_iterator i = impl->first_edge_to(head); + i != impl->_dst_edges.end() && (*i)->impl->head == head;) { + GanvCanvasImpl::Edges::const_iterator next = i; + ++next; + f((*i), data); + i = next; + } } void @@ -2466,7 +2416,18 @@ ganv_canvas_for_each_edge_on(GanvCanvas* canvas, GanvEdgeFunc f, void* data) { - canvas->impl->for_each_edge_on(node, f, data); + ganv_canvas_for_each_edge_from(canvas, node, f, data); + ganv_canvas_for_each_edge_to(canvas, node, f, data); +} + +void +ganv_canvas_for_each_selected_edge(GanvCanvas* canvas, + GanvEdgeFunc f, + void* data) +{ + FOREACH_EDGE(canvas->impl->_selected_edges, i) { + f((*i), data); + } } GdkCursor* @@ -2509,15 +2470,15 @@ void ganv_canvas_select_all(GanvCanvas* canvas) { ganv_canvas_clear_selection(canvas); - FOREACH_ITEM(canvas->impl->_items, m) { - canvas->impl->select_item(*m); + FOREACH_ITEM(canvas->impl->_items, i) { + ganv_canvas_select_node(canvas, *i); } } double ganv_canvas_get_zoom(GanvCanvas* canvas) { - return canvas->impl->_zoom; + return canvas->impl->pixels_per_unit; } void @@ -2553,11 +2514,11 @@ ganv_canvas_arrange(GanvCanvas* canvas) if (GANV_ITEM(i->first)->parent != GANV_ITEM(ganv_canvas_root(canvas))) { continue; } - const string pos = agget(i->second, (char*)"pos"); - const string x_str = pos.substr(0, pos.find(",")); - const string y_str = pos.substr(pos.find(",") + 1); - const double cx = lrint(strtod(x_str.c_str(), NULL) * dpp); - const double cy = lrint(strtod(y_str.c_str(), NULL) * dpp); + const std::string pos = agget(i->second, (char*)"pos"); + const std::string x_str = pos.substr(0, pos.find(",")); + const std::string y_str = pos.substr(pos.find(",") + 1); + const double cx = lrint(strtod(x_str.c_str(), NULL) * dpp); + const double cy = lrint(strtod(y_str.c_str(), NULL) * dpp); double w, h; if (GANV_IS_BOX(i->first)) { @@ -2604,7 +2565,7 @@ ganv_canvas_arrange(GanvCanvas* canvas) } nodes.cleanup(); - static const double border_width = canvas->impl->_font_size * 2.0; + static const double border_width = canvas->impl->font_size * 2.0; canvas->impl->move_contents_to_internal(border_width, border_width, least_x, least_y); ganv_canvas_scroll_to(GANV_CANVAS(canvas->impl->_gcanvas), 0, 0); @@ -2630,19 +2591,22 @@ ganv_canvas_export_dot(GanvCanvas* canvas, const char* filename) #endif } - -/***************************************************************************/ +gboolean +ganv_canvas_get_locked(GanvCanvas* canvas) +{ + return canvas->impl->locked; +} /* Convenience function to remove the idle handler of a canvas */ static void remove_idle(GanvCanvas* canvas) { - if (canvas->idle_id == 0) { + if (canvas->impl->idle_id == 0) { return; } - g_source_remove(canvas->idle_id); - canvas->idle_id = 0; + g_source_remove(canvas->impl->idle_id); + canvas->impl->idle_id = 0; } /* Removes the transient state of the canvas (idle handler, grabs). */ @@ -2654,19 +2618,19 @@ shutdown_transients(GanvCanvas* canvas) * flag, though, because updates are not queued when the canvas remaps * itself. */ - if (canvas->need_redraw) { - canvas->need_redraw = FALSE; - g_slist_foreach(canvas->redraw_region, (GFunc)g_free, NULL); - g_slist_free(canvas->redraw_region); - canvas->redraw_region = NULL; - canvas->redraw_x1 = 0; - canvas->redraw_y1 = 0; - canvas->redraw_x2 = 0; - canvas->redraw_y2 = 0; - } - - if (canvas->grabbed_item) { - canvas->grabbed_item = NULL; + if (canvas->impl->need_redraw) { + canvas->impl->need_redraw = FALSE; + g_slist_foreach(canvas->impl->redraw_region, (GFunc)g_free, NULL); + g_slist_free(canvas->impl->redraw_region); + canvas->impl->redraw_region = NULL; + canvas->impl->redraw_x1 = 0; + canvas->impl->redraw_y1 = 0; + canvas->impl->redraw_x2 = 0; + canvas->impl->redraw_y2 = 0; + } + + if (canvas->impl->grabbed_item) { + canvas->impl->grabbed_item = NULL; gdk_pointer_ungrab(GDK_CURRENT_TIME); } @@ -2677,22 +2641,20 @@ shutdown_transients(GanvCanvas* canvas) static void ganv_canvas_destroy(GtkObject* object) { - GanvCanvas* canvas; - g_return_if_fail(GANV_IS_CANVAS(object)); /* remember, destroy can be run multiple times! */ - canvas = GANV_CANVAS(object); + GanvCanvas* canvas = GANV_CANVAS(object); - if (canvas->root_destroy_id) { - g_signal_handler_disconnect(canvas->root, canvas->root_destroy_id); - canvas->root_destroy_id = 0; + if (canvas->impl->root_destroy_id) { + g_signal_handler_disconnect(canvas->impl->root, canvas->impl->root_destroy_id); + canvas->impl->root_destroy_id = 0; } - if (canvas->root) { - gtk_object_destroy(GTK_OBJECT(canvas->root)); - g_object_unref(G_OBJECT(canvas->root)); - canvas->root = NULL; + if (canvas->impl->root) { + gtk_object_destroy(GTK_OBJECT(canvas->impl->root)); + g_object_unref(G_OBJECT(canvas->impl->root)); + canvas->impl->root = NULL; } shutdown_transients(canvas); @@ -2717,7 +2679,7 @@ ganv_canvas_new(double width, double height) NULL)); ganv_canvas_set_scroll_region(GANV_CANVAS(canvas), - 0.0, 0.0, width, height); + 0.0, 0.0, width, height); return canvas; } @@ -2738,14 +2700,14 @@ ganv_canvas_map(GtkWidget* widget) canvas = GANV_CANVAS(widget); - if (canvas->need_update) { + if (canvas->impl->need_update) { add_idle(canvas); } /* Map items */ - if (GANV_ITEM_GET_CLASS(canvas->root)->map) { - (*GANV_ITEM_GET_CLASS(canvas->root)->map)(canvas->root); + if (GANV_ITEM_GET_CLASS(canvas->impl->root)->map) { + (*GANV_ITEM_GET_CLASS(canvas->impl->root)->map)(canvas->impl->root); } } @@ -2763,8 +2725,8 @@ ganv_canvas_unmap(GtkWidget* widget) /* Unmap items */ - if (GANV_ITEM_GET_CLASS(canvas->root)->unmap) { - (*GANV_ITEM_GET_CLASS(canvas->root)->unmap)(canvas->root); + if (GANV_ITEM_GET_CLASS(canvas->impl->root)->unmap) { + (*GANV_ITEM_GET_CLASS(canvas->impl->root)->unmap)(canvas->impl->root); } /* Normal widget unmapping stuff */ @@ -2805,9 +2767,9 @@ ganv_canvas_realize(GtkWidget* widget) /* Create our own temporary pixmap gc and realize all the items */ - canvas->pixmap_gc = gdk_gc_new(canvas->layout.bin_window); + canvas->impl->pixmap_gc = gdk_gc_new(canvas->layout.bin_window); - (*GANV_ITEM_GET_CLASS(canvas->root)->realize)(canvas->root); + (*GANV_ITEM_GET_CLASS(canvas->impl->root)->realize)(canvas->impl->root); } /* Unrealize handler for the canvas */ @@ -2824,10 +2786,10 @@ ganv_canvas_unrealize(GtkWidget* widget) /* Unrealize items and parent widget */ - (*GANV_ITEM_GET_CLASS(canvas->root)->unrealize)(canvas->root); + (*GANV_ITEM_GET_CLASS(canvas->impl->root)->unrealize)(canvas->impl->root); - g_object_unref(canvas->pixmap_gc); - canvas->pixmap_gc = NULL; + g_object_unref(canvas->impl->pixmap_gc); + canvas->impl->pixmap_gc = NULL; if (GTK_WIDGET_CLASS(canvas_parent_class)->unrealize) { (*GTK_WIDGET_CLASS(canvas_parent_class)->unrealize)(widget); @@ -2849,56 +2811,56 @@ scroll_to(GanvCanvas* canvas, int cx, int cy) canvas_width = GTK_WIDGET(canvas)->allocation.width; canvas_height = GTK_WIDGET(canvas)->allocation.height; - scroll_width = floor((canvas->scroll_x2 - canvas->scroll_x1) * canvas->pixels_per_unit + scroll_width = floor((canvas->impl->scroll_x2 - canvas->impl->scroll_x1) * canvas->impl->pixels_per_unit + 0.5); - scroll_height = floor((canvas->scroll_y2 - canvas->scroll_y1) * canvas->pixels_per_unit + scroll_height = floor((canvas->impl->scroll_y2 - canvas->impl->scroll_y1) * canvas->impl->pixels_per_unit + 0.5); right_limit = scroll_width - canvas_width; bottom_limit = scroll_height - canvas_height; - old_zoom_xofs = canvas->zoom_xofs; - old_zoom_yofs = canvas->zoom_yofs; + old_zoom_xofs = canvas->impl->zoom_xofs; + old_zoom_yofs = canvas->impl->zoom_yofs; if (right_limit < 0) { cx = 0; - if (canvas->center_scroll_region) { - canvas->zoom_xofs = (canvas_width - scroll_width) / 2; + if (canvas->impl->center_scroll_region) { + canvas->impl->zoom_xofs = (canvas_width - scroll_width) / 2; scroll_width = canvas_width; } else { - canvas->zoom_xofs = 0; + canvas->impl->zoom_xofs = 0; } } else if (cx < 0) { cx = 0; - canvas->zoom_xofs = 0; + canvas->impl->zoom_xofs = 0; } else if (cx > right_limit) { cx = right_limit; - canvas->zoom_xofs = 0; + canvas->impl->zoom_xofs = 0; } else { - canvas->zoom_xofs = 0; + canvas->impl->zoom_xofs = 0; } if (bottom_limit < 0) { cy = 0; - if (canvas->center_scroll_region) { - canvas->zoom_yofs = (canvas_height - scroll_height) / 2; + if (canvas->impl->center_scroll_region) { + canvas->impl->zoom_yofs = (canvas_height - scroll_height) / 2; scroll_height = canvas_height; } else { - canvas->zoom_yofs = 0; + canvas->impl->zoom_yofs = 0; } } else if (cy < 0) { cy = 0; - canvas->zoom_yofs = 0; + canvas->impl->zoom_yofs = 0; } else if (cy > bottom_limit) { cy = bottom_limit; - canvas->zoom_yofs = 0; + canvas->impl->zoom_yofs = 0; } else { - canvas->zoom_yofs = 0; + canvas->impl->zoom_yofs = 0; } - if ((canvas->zoom_xofs != old_zoom_xofs) || (canvas->zoom_yofs != old_zoom_yofs)) { + if ((canvas->impl->zoom_xofs != old_zoom_xofs) || (canvas->impl->zoom_yofs != old_zoom_yofs)) { ganv_canvas_request_update(canvas); gtk_widget_queue_draw(GTK_WIDGET(canvas)); } @@ -2988,8 +2950,8 @@ ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event) /* Perform checks for grabbed items */ - if (canvas->grabbed_item - && !is_descendant(canvas->current_item, canvas->grabbed_item)) { + if (canvas->impl->grabbed_item + && !is_descendant(canvas->impl->current_item, canvas->impl->grabbed_item)) { /* I think this warning is annoying and I don't know what it's for * so I'll disable it for now. */ @@ -2997,7 +2959,7 @@ ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event) return FALSE; } - if (canvas->grabbed_item) { + if (canvas->impl->grabbed_item) { switch (event->type) { case GDK_ENTER_NOTIFY: mask = GDK_ENTER_NOTIFY_MASK; @@ -3038,7 +3000,7 @@ ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event) break; } - if (!(mask & canvas->grabbed_event_mask)) { + if (!(mask & canvas->impl->grabbed_event_mask)) { return FALSE; } } @@ -3053,8 +3015,8 @@ ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event) case GDK_ENTER_NOTIFY: case GDK_LEAVE_NOTIFY: ganv_canvas_window_to_world(canvas, - ev->crossing.x, ev->crossing.y, - &ev->crossing.x, &ev->crossing.y); + ev->crossing.x, ev->crossing.y, + &ev->crossing.x, &ev->crossing.y); break; case GDK_MOTION_NOTIFY: @@ -3063,8 +3025,8 @@ ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event) case GDK_3BUTTON_PRESS: case GDK_BUTTON_RELEASE: ganv_canvas_window_to_world(canvas, - ev->motion.x, ev->motion.y, - &ev->motion.x, &ev->motion.y); + ev->motion.x, ev->motion.y, + &ev->motion.x, &ev->motion.y); break; default: @@ -3073,13 +3035,13 @@ ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event) /* Choose where we send the event */ - item = canvas->current_item; + item = canvas->impl->current_item; - if (canvas->focused_item + if (canvas->impl->focused_item && ((event->type == GDK_KEY_PRESS) || (event->type == GDK_KEY_RELEASE) || (event->type == GDK_FOCUS_CHANGE))) { - item = canvas->focused_item; + item = canvas->impl->focused_item; } /* The event is propagated up the hierarchy (for if someone connected to @@ -3105,6 +3067,145 @@ ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event) return finished; } +void +ganv_canvas_set_need_repick(GanvCanvas* canvas) +{ + canvas->impl->need_repick = TRUE; +} + +void +ganv_canvas_forget_item(GanvCanvas* canvas, GanvItem* item) +{ + if (canvas->impl && item == canvas->impl->current_item) { + canvas->impl->current_item = NULL; + canvas->impl->need_repick = TRUE; + } + + if (canvas->impl && item == canvas->impl->new_current_item) { + canvas->impl->new_current_item = NULL; + canvas->impl->need_repick = TRUE; + } + + if (canvas->impl && item == canvas->impl->grabbed_item) { + canvas->impl->grabbed_item = NULL; + gdk_pointer_ungrab(GDK_CURRENT_TIME); + } + + if (canvas->impl && item == canvas->impl->focused_item) { + canvas->impl->focused_item = NULL; + } +} + +void +ganv_canvas_grab_focus(GanvCanvas* canvas, GanvItem* item) +{ + g_return_if_fail(GANV_IS_ITEM(item)); + g_return_if_fail(GTK_WIDGET_CAN_FOCUS(GTK_WIDGET(canvas))); + + GanvItem* focused_item = canvas->impl->focused_item; + GdkEvent ev; + + if (focused_item) { + ev.focus_change.type = GDK_FOCUS_CHANGE; + ev.focus_change.window = canvas->layout.bin_window; + ev.focus_change.send_event = FALSE; + ev.focus_change.in = FALSE; + + ganv_canvas_emit_event(canvas, &ev); + } + + canvas->impl->focused_item = item; + gtk_widget_grab_focus(GTK_WIDGET(canvas)); + + if (focused_item) { + ev.focus_change.type = GDK_FOCUS_CHANGE; + ev.focus_change.window = canvas->layout.bin_window; + ev.focus_change.send_event = FALSE; + ev.focus_change.in = TRUE; + + ganv_canvas_emit_event(canvas, &ev); + } +} + +/** + * ganv_canvas_grab_item: + * @item: A canvas item. + * @event_mask: Mask of events that will be sent to this item. + * @cursor: If non-NULL, the cursor that will be used while the grab is active. + * @etime: The timestamp required for grabbing the mouse, or GDK_CURRENT_TIME. + * + * Specifies that all events that match the specified event mask should be sent + * to the specified item, and also grabs the mouse by calling + * gdk_pointer_grab(). The event mask is also used when grabbing the pointer. + * If @cursor is not NULL, then that cursor is used while the grab is active. + * The @etime parameter is the timestamp required for grabbing the mouse. + * + * Return value: If an item was already grabbed, it returns %GDK_GRAB_ALREADY_GRABBED. If + * the specified item was hidden by calling ganv_item_hide(), then it + * returns %GDK_GRAB_NOT_VIEWABLE. Else, it returns the result of calling + * gdk_pointer_grab(). + **/ +int +ganv_canvas_grab_item(GanvItem* item, guint event_mask, GdkCursor* cursor, guint32 etime) +{ + g_return_val_if_fail(GANV_IS_ITEM(item), GDK_GRAB_NOT_VIEWABLE); + g_return_val_if_fail(GTK_WIDGET_MAPPED(item->canvas), GDK_GRAB_NOT_VIEWABLE); + + if (item->canvas->impl->grabbed_item) { + return GDK_GRAB_ALREADY_GRABBED; + } + + if (!(item->object.flags & GANV_ITEM_VISIBLE)) { + return GDK_GRAB_NOT_VIEWABLE; + } + + int retval = gdk_pointer_grab(item->canvas->layout.bin_window, + FALSE, + (GdkEventMask)event_mask, + NULL, + cursor, + etime); + + if (retval != GDK_GRAB_SUCCESS) { + return retval; + } + + item->canvas->impl->grabbed_item = item; + item->canvas->impl->grabbed_event_mask = event_mask; + item->canvas->impl->current_item = item; /* So that events go to the grabbed item */ + + return retval; +} + +/** + * ganv_canvas_ungrab_item: + * @item: A canvas item that holds a grab. + * @etime: The timestamp for ungrabbing the mouse. + * + * Ungrabs the item, which must have been grabbed in the canvas, and ungrabs the + * mouse. + **/ +void +ganv_canvas_ungrab_item(GanvItem* item, guint32 etime) +{ + g_return_if_fail(GANV_IS_ITEM(item)); + + if (item->canvas->impl->grabbed_item != item) { + return; + } + + item->canvas->impl->grabbed_item = NULL; + + gdk_pointer_ungrab(etime); +} + +void +ganv_canvas_get_zoom_offsets(GanvCanvas* canvas, int* x, int* y) +{ + *x = canvas->impl->zoom_xofs; + *y = canvas->impl->zoom_yofs; +} + /* Re-picks the current item in the canvas, based on the event's coordinates. * Also emits enter/leave events for items as appropriate. */ @@ -3122,13 +3223,13 @@ pick_current_item(GanvCanvas* canvas, GdkEvent* event) * current item, but not enter on any other item. This is more or less * like X pointer grabbing for canvas items. */ - button_down = canvas->state & (GDK_BUTTON1_MASK - | GDK_BUTTON2_MASK - | GDK_BUTTON3_MASK - | GDK_BUTTON4_MASK - | GDK_BUTTON5_MASK); + button_down = canvas->impl->state & (GDK_BUTTON1_MASK + | GDK_BUTTON2_MASK + | GDK_BUTTON3_MASK + | GDK_BUTTON4_MASK + | GDK_BUTTON5_MASK); if (!button_down) { - canvas->left_grabbed_item = FALSE; + canvas->impl->left_grabbed_item = FALSE; } /* Save the event in the canvas. This is used to synthesize enter and @@ -3136,52 +3237,52 @@ pick_current_item(GanvCanvas* canvas, GdkEvent* event) * re-pick the current item if the current one gets deleted. Also, * synthesize an enter event. */ - if (event != &canvas->pick_event) { + if (event != &canvas->impl->pick_event) { if ((event->type == GDK_MOTION_NOTIFY) || (event->type == GDK_BUTTON_RELEASE)) { /* these fields have the same offsets in both types of events */ - canvas->pick_event.crossing.type = GDK_ENTER_NOTIFY; - canvas->pick_event.crossing.window = event->motion.window; - canvas->pick_event.crossing.send_event = event->motion.send_event; - canvas->pick_event.crossing.subwindow = NULL; - canvas->pick_event.crossing.x = event->motion.x; - canvas->pick_event.crossing.y = event->motion.y; - canvas->pick_event.crossing.mode = GDK_CROSSING_NORMAL; - canvas->pick_event.crossing.detail = GDK_NOTIFY_NONLINEAR; - canvas->pick_event.crossing.focus = FALSE; - canvas->pick_event.crossing.state = event->motion.state; + canvas->impl->pick_event.crossing.type = GDK_ENTER_NOTIFY; + canvas->impl->pick_event.crossing.window = event->motion.window; + canvas->impl->pick_event.crossing.send_event = event->motion.send_event; + canvas->impl->pick_event.crossing.subwindow = NULL; + canvas->impl->pick_event.crossing.x = event->motion.x; + canvas->impl->pick_event.crossing.y = event->motion.y; + canvas->impl->pick_event.crossing.mode = GDK_CROSSING_NORMAL; + canvas->impl->pick_event.crossing.detail = GDK_NOTIFY_NONLINEAR; + canvas->impl->pick_event.crossing.focus = FALSE; + canvas->impl->pick_event.crossing.state = event->motion.state; /* these fields don't have the same offsets in both types of events */ if (event->type == GDK_MOTION_NOTIFY) { - canvas->pick_event.crossing.x_root = event->motion.x_root; - canvas->pick_event.crossing.y_root = event->motion.y_root; + canvas->impl->pick_event.crossing.x_root = event->motion.x_root; + canvas->impl->pick_event.crossing.y_root = event->motion.y_root; } else { - canvas->pick_event.crossing.x_root = event->button.x_root; - canvas->pick_event.crossing.y_root = event->button.y_root; + canvas->impl->pick_event.crossing.x_root = event->button.x_root; + canvas->impl->pick_event.crossing.y_root = event->button.y_root; } } else { - canvas->pick_event = *event; + canvas->impl->pick_event = *event; } } /* Don't do anything else if this is a recursive call */ - if (canvas->in_repick) { + if (canvas->impl->in_repick) { return retval; } /* LeaveNotify means that there is no current item, so we don't look for one */ - if (canvas->pick_event.type != GDK_LEAVE_NOTIFY) { + if (canvas->impl->pick_event.type != GDK_LEAVE_NOTIFY) { /* these fields don't have the same offsets in both types of events */ - if (canvas->pick_event.type == GDK_ENTER_NOTIFY) { - x = canvas->pick_event.crossing.x - canvas->zoom_xofs; - y = canvas->pick_event.crossing.y - canvas->zoom_yofs; + if (canvas->impl->pick_event.type == GDK_ENTER_NOTIFY) { + x = canvas->impl->pick_event.crossing.x - canvas->impl->zoom_xofs; + y = canvas->impl->pick_event.crossing.y - canvas->impl->zoom_yofs; } else { - x = canvas->pick_event.motion.x - canvas->zoom_xofs; - y = canvas->pick_event.motion.y - canvas->zoom_yofs; + x = canvas->impl->pick_event.motion.x - canvas->impl->zoom_xofs; + y = canvas->impl->pick_event.motion.y - canvas->impl->zoom_yofs; } /* canvas pixel coords */ @@ -3191,61 +3292,61 @@ pick_current_item(GanvCanvas* canvas, GdkEvent* event) /* world coords */ - x = canvas->scroll_x1 + x / canvas->pixels_per_unit; - y = canvas->scroll_y1 + y / canvas->pixels_per_unit; + x = canvas->impl->scroll_x1 + x / canvas->impl->pixels_per_unit; + y = canvas->impl->scroll_y1 + y / canvas->impl->pixels_per_unit; /* find the closest item */ - if (canvas->root->object.flags & GANV_ITEM_VISIBLE) { - GANV_ITEM_GET_CLASS(canvas->root)->point( - canvas->root, - x - canvas->root->x, y - canvas->root->y, + if (canvas->impl->root->object.flags & GANV_ITEM_VISIBLE) { + GANV_ITEM_GET_CLASS(canvas->impl->root)->point( + canvas->impl->root, + x - canvas->impl->root->x, y - canvas->impl->root->y, cx, cy, - &canvas->new_current_item); + &canvas->impl->new_current_item); } else { - canvas->new_current_item = NULL; + canvas->impl->new_current_item = NULL; } } else { - canvas->new_current_item = NULL; + canvas->impl->new_current_item = NULL; } - if ((canvas->new_current_item == canvas->current_item) && !canvas->left_grabbed_item) { + if ((canvas->impl->new_current_item == canvas->impl->current_item) && !canvas->impl->left_grabbed_item) { return retval; /* current item did not change */ } /* Synthesize events for old and new current items */ - if ((canvas->new_current_item != canvas->current_item) - && (canvas->current_item != NULL) - && !canvas->left_grabbed_item) { + if ((canvas->impl->new_current_item != canvas->impl->current_item) + && (canvas->impl->current_item != NULL) + && !canvas->impl->left_grabbed_item) { GdkEvent new_event; - new_event = canvas->pick_event; + new_event = canvas->impl->pick_event; new_event.type = GDK_LEAVE_NOTIFY; new_event.crossing.detail = GDK_NOTIFY_ANCESTOR; new_event.crossing.subwindow = NULL; - canvas->in_repick = TRUE; + canvas->impl->in_repick = TRUE; retval = ganv_canvas_emit_event(canvas, &new_event); - canvas->in_repick = FALSE; + canvas->impl->in_repick = FALSE; } /* new_current_item may have been set to NULL during the call to ganv_canvas_emit_event() above */ - if ((canvas->new_current_item != canvas->current_item) && button_down) { - canvas->left_grabbed_item = TRUE; + if ((canvas->impl->new_current_item != canvas->impl->current_item) && button_down) { + canvas->impl->left_grabbed_item = TRUE; return retval; } /* Handle the rest of cases */ - canvas->left_grabbed_item = FALSE; - canvas->current_item = canvas->new_current_item; + canvas->impl->left_grabbed_item = FALSE; + canvas->impl->current_item = canvas->impl->new_current_item; - if (canvas->current_item != NULL) { + if (canvas->impl->current_item != NULL) { GdkEvent new_event; - new_event = canvas->pick_event; + new_event = canvas->impl->pick_event; new_event.type = GDK_ENTER_NOTIFY; new_event.crossing.detail = GDK_NOTIFY_ANCESTOR; new_event.crossing.subwindow = NULL; @@ -3274,7 +3375,7 @@ ganv_canvas_button(GtkWidget* widget, GdkEventButton* event) * dispatch normally regardless of the event's window if an item has * has a pointer grab in effect */ - if (!canvas->grabbed_item && ( event->window != canvas->layout.bin_window) ) { + if (!canvas->impl->grabbed_item && ( event->window != canvas->layout.bin_window) ) { return retval; } @@ -3305,9 +3406,9 @@ ganv_canvas_button(GtkWidget* widget, GdkEventButton* event) /* Pick the current item as if the button were not pressed, and * then process the event. */ - canvas->state = event->state; + canvas->impl->state = event->state; pick_current_item(canvas, (GdkEvent*)event); - canvas->state ^= mask; + canvas->impl->state ^= mask; retval = ganv_canvas_emit_event(canvas, (GdkEvent*)event); break; @@ -3315,10 +3416,10 @@ ganv_canvas_button(GtkWidget* widget, GdkEventButton* event) /* Process the event as if the button were pressed, then repick * after the button has been released */ - canvas->state = event->state; + canvas->impl->state = event->state; retval = ganv_canvas_emit_event(canvas, (GdkEvent*)event); event->state ^= mask; - canvas->state = event->state; + canvas->impl->state = event->state; pick_current_item(canvas, (GdkEvent*)event); event->state ^= mask; break; @@ -3345,7 +3446,7 @@ ganv_canvas_motion(GtkWidget* widget, GdkEventMotion* event) return FALSE; } - canvas->state = event->state; + canvas->impl->state = event->state; pick_current_item(canvas, (GdkEvent*)event); return ganv_canvas_emit_event(canvas, (GdkEvent*)event); } @@ -3364,7 +3465,7 @@ ganv_canvas_scroll(GtkWidget* widget, GdkEventScroll* event) return FALSE; } - canvas->state = event->state; + canvas->impl->state = event->state; pick_current_item(canvas, (GdkEvent*)event); return ganv_canvas_emit_event(canvas, (GdkEvent*)event); } @@ -3418,7 +3519,7 @@ ganv_canvas_crossing(GtkWidget* widget, GdkEventCrossing* event) return FALSE; } - canvas->state = event->state; + canvas->impl->state = event->state; return pick_current_item(canvas, (GdkEvent*)event); } @@ -3432,7 +3533,7 @@ ganv_canvas_focus_in(GtkWidget* widget, GdkEventFocus* event) canvas = GANV_CANVAS(widget); - if (canvas->focused_item) { + if (canvas->impl->focused_item) { return ganv_canvas_emit_event(canvas, (GdkEvent*)event); } else { return FALSE; @@ -3449,7 +3550,7 @@ ganv_canvas_focus_out(GtkWidget* widget, GdkEventFocus* event) canvas = GANV_CANVAS(widget); - if (canvas->focused_item) { + if (canvas->impl->focused_item) { return ganv_canvas_emit_event(canvas, (GdkEvent*)event); } else { return FALSE; @@ -3465,10 +3566,10 @@ ganv_canvas_paint_rect(GanvCanvas* canvas, gint x0, gint y0, gint x1, gint y1) gint draw_x2, draw_y2; gint draw_width, draw_height; - g_return_if_fail(!canvas->need_update); + g_return_if_fail(!canvas->impl->need_update); - draw_x1 = MAX(x0, canvas->layout.hadjustment->value - canvas->zoom_xofs); - draw_y1 = MAX(y0, canvas->layout.vadjustment->value - canvas->zoom_yofs); + draw_x1 = MAX(x0, canvas->layout.hadjustment->value - canvas->impl->zoom_xofs); + draw_y1 = MAX(y0, canvas->layout.vadjustment->value - canvas->impl->zoom_yofs); draw_x2 = MIN(draw_x1 + GTK_WIDGET(canvas)->allocation.width, x1); draw_y2 = MIN(draw_y1 + GTK_WIDGET(canvas)->allocation.height, y1); @@ -3479,12 +3580,12 @@ ganv_canvas_paint_rect(GanvCanvas* canvas, gint x0, gint y0, gint x1, gint y1) return; } - canvas->redraw_x1 = draw_x1; - canvas->redraw_y1 = draw_y1; - canvas->redraw_x2 = draw_x2; - canvas->redraw_y2 = draw_y2; - canvas->draw_xofs = draw_x1; - canvas->draw_yofs = draw_y1; + canvas->impl->redraw_x1 = draw_x1; + canvas->impl->redraw_y1 = draw_y1; + canvas->impl->redraw_x2 = draw_x2; + canvas->impl->redraw_y2 = draw_y2; + canvas->impl->draw_xofs = draw_x1; + canvas->impl->draw_yofs = draw_y1; cairo_t* cr = gdk_cairo_create(canvas->layout.bin_window); @@ -3492,11 +3593,11 @@ ganv_canvas_paint_rect(GanvCanvas* canvas, gint x0, gint y0, gint x1, gint y1) ganv_canvas_window_to_world(canvas, 0, 0, &wx, &wy); cairo_translate(cr, -wx, -wy); - if (canvas->root->object.flags & GANV_ITEM_VISIBLE) { - (*GANV_ITEM_GET_CLASS(canvas->root)->draw)( - canvas->root, cr, - draw_x1, draw_y1, - draw_width, draw_height); + if (canvas->impl->root->object.flags & GANV_ITEM_VISIBLE) { + (*GANV_ITEM_GET_CLASS(canvas->impl->root)->draw)( + canvas->impl->root, cr, + draw_x1, draw_y1, + draw_width, draw_height); } cairo_destroy(cr); @@ -3523,7 +3624,7 @@ ganv_canvas_expose(GtkWidget* widget, GdkEventExpose* event) const int x2 = clip.x + clip.width; const int y2 = clip.y + clip.height; - if (canvas->need_update || canvas->need_redraw) { + if (canvas->impl->need_update || canvas->impl->need_redraw) { /* Update or drawing is scheduled, so just mark exposed area as dirty */ ganv_canvas_request_redraw(canvas, clip.x, clip.y, x2, y2); } else { @@ -3544,12 +3645,12 @@ ganv_canvas_expose(GtkWidget* widget, GdkEventExpose* event) static void paint(GanvCanvas* canvas) { - for (GSList* l = canvas->redraw_region; l; l = l->next) { + for (GSList* l = canvas->impl->redraw_region; l; l = l->next) { IRect* rect = (IRect*)l->data; const GdkRectangle gdkrect = { - rect->x + canvas->zoom_xofs, - rect->y + canvas->zoom_yofs, + rect->x + canvas->impl->zoom_xofs, + rect->y + canvas->impl->zoom_yofs, rect->width, rect->height }; @@ -3558,14 +3659,14 @@ paint(GanvCanvas* canvas) g_free(rect); } - g_slist_free(canvas->redraw_region); - canvas->redraw_region = NULL; - canvas->need_redraw = FALSE; + g_slist_free(canvas->impl->redraw_region); + canvas->impl->redraw_region = NULL; + canvas->impl->need_redraw = FALSE; - canvas->redraw_x1 = 0; - canvas->redraw_y1 = 0; - canvas->redraw_x2 = 0; - canvas->redraw_y2 = 0; + canvas->impl->redraw_x1 = 0; + canvas->impl->redraw_y1 = 0; + canvas->impl->redraw_x2 = 0; + canvas->impl->redraw_y2 = 0; } static void @@ -3574,17 +3675,17 @@ do_update(GanvCanvas* canvas) /* Cause the update if necessary */ update_again: - if (canvas->need_update) { - ganv_item_invoke_update(canvas->root, 0); + if (canvas->impl->need_update) { + ganv_item_invoke_update(canvas->impl->root, 0); - canvas->need_update = FALSE; + canvas->impl->need_update = FALSE; } /* Pick new current item */ - while (canvas->need_repick) { - canvas->need_repick = FALSE; - pick_current_item(canvas, &canvas->pick_event); + while (canvas->impl->need_repick) { + canvas->impl->need_repick = FALSE; + pick_current_item(canvas, &canvas->impl->pick_event); } /* it is possible that during picking we emitted an event in which @@ -3592,13 +3693,13 @@ update_again: of something. Without this we'd be left in a state where need_update would have been left TRUE and the canvas would have been left unpainted. */ - if (canvas->need_update) { + if (canvas->impl->need_update) { goto update_again; } /* Paint if able to */ - if (GTK_WIDGET_DRAWABLE(canvas) && canvas->need_redraw) { + if (GTK_WIDGET_DRAWABLE(canvas) && canvas->impl->need_redraw) { paint(canvas); } } @@ -3616,7 +3717,7 @@ idle_handler(gpointer data) do_update(canvas); /* Reset idle id */ - canvas->idle_id = 0; + canvas->impl->idle_id = 0; GDK_THREADS_LEAVE(); @@ -3627,13 +3728,13 @@ idle_handler(gpointer data) static void add_idle(GanvCanvas* canvas) { - g_assert(canvas->need_update || canvas->need_redraw); + g_assert(canvas->impl->need_update || canvas->impl->need_redraw); - if (!canvas->idle_id) { - canvas->idle_id = g_idle_add_full(CANVAS_IDLE_PRIORITY, - idle_handler, - canvas, - NULL); + if (!canvas->impl->idle_id) { + canvas->impl->idle_id = g_idle_add_full(CANVAS_IDLE_PRIORITY, + idle_handler, + canvas, + NULL); } /* canvas->idle_id = gtk_idle_add (idle_handler, canvas); */ @@ -3650,7 +3751,7 @@ ganv_canvas_root(GanvCanvas* canvas) { g_return_val_if_fail(GANV_IS_CANVAS(canvas), NULL); - return canvas->root; + return canvas->impl->root; } /** @@ -3667,7 +3768,7 @@ ganv_canvas_root(GanvCanvas* canvas) **/ void ganv_canvas_set_scroll_region(GanvCanvas* canvas, double x1, double y1, double x2, - double y2) + double y2) { double wxofs, wyofs; int xofs, yofs; @@ -3680,26 +3781,26 @@ ganv_canvas_set_scroll_region(GanvCanvas* canvas, double x1, double y1, double x */ ganv_canvas_c2w(canvas, - GTK_LAYOUT(canvas)->hadjustment->value + canvas->zoom_xofs, - GTK_LAYOUT(canvas)->vadjustment->value + canvas->zoom_yofs, - /*canvas->zoom_xofs, - canvas->zoom_yofs,*/ - &wxofs, &wyofs); + GTK_LAYOUT(canvas)->hadjustment->value + canvas->impl->zoom_xofs, + GTK_LAYOUT(canvas)->vadjustment->value + canvas->impl->zoom_yofs, + /*canvas->impl->zoom_xofs, + canvas->impl->zoom_yofs,*/ + &wxofs, &wyofs); - canvas->scroll_x1 = x1; - canvas->scroll_y1 = y1; - canvas->scroll_x2 = x2; - canvas->scroll_y2 = y2; + canvas->impl->scroll_x1 = x1; + canvas->impl->scroll_y1 = y1; + canvas->impl->scroll_x2 = x2; + canvas->impl->scroll_y2 = y2; ganv_canvas_w2c(canvas, wxofs, wyofs, &xofs, &yofs); scroll_to(canvas, xofs, yofs); - canvas->need_repick = TRUE; + canvas->impl->need_repick = TRUE; #if 0 /* todo: should be requesting update */ - (*GANV_ITEM_CLASS(canvas->root->object.klass)->update)( - canvas->root, NULL, NULL, 0); + (*GANV_ITEM_CLASS(canvas->impl->root->object.klass)->update)( + canvas->impl->root, NULL, NULL, 0); #endif } @@ -3715,24 +3816,24 @@ ganv_canvas_set_scroll_region(GanvCanvas* canvas, double x1, double y1, double x **/ void ganv_canvas_get_scroll_region(GanvCanvas* canvas, double* x1, double* y1, double* x2, - double* y2) + double* y2) { g_return_if_fail(GANV_IS_CANVAS(canvas)); if (x1) { - *x1 = canvas->scroll_x1; + *x1 = canvas->impl->scroll_x1; } if (y1) { - *y1 = canvas->scroll_y1; + *y1 = canvas->impl->scroll_y1; } if (x2) { - *x2 = canvas->scroll_x2; + *x2 = canvas->impl->scroll_x2; } if (y2) { - *y2 = canvas->scroll_y2; + *y2 = canvas->impl->scroll_y2; } } @@ -3752,7 +3853,7 @@ ganv_canvas_set_center_scroll_region(GanvCanvas* canvas, gboolean center_scroll_ { g_return_if_fail(GANV_IS_CANVAS(canvas)); - canvas->center_scroll_region = center_scroll_region != 0; + canvas->impl->center_scroll_region = center_scroll_region != 0; scroll_to(canvas, canvas->layout.hadjustment->value, @@ -3773,68 +3874,7 @@ ganv_canvas_get_center_scroll_region(GanvCanvas* canvas) { g_return_val_if_fail(GANV_IS_CANVAS(canvas), FALSE); - return canvas->center_scroll_region ? TRUE : FALSE; -} - -/** - * ganv_canvas_set_pixels_per_unit: - * @canvas: A canvas. - * @n: The number of pixels that correspond to one canvas unit. - * - * Sets the zooming factor of a canvas by specifying the number of pixels that - * correspond to one canvas unit. - * - * The anchor point for zooming, i.e. the point that stays fixed and all others - * zoom inwards or outwards from it, depends on whether the canvas is set to - * center the scrolling region or not. You can control this using the - * ganv_canvas_set_center_scroll_region() function. If the canvas is set to - * center the scroll region, then the center of the canvas window is used as the - * anchor point for zooming. Otherwise, the upper-left corner of the canvas - * window is used as the anchor point. - **/ -void -ganv_canvas_set_pixels_per_unit(GanvCanvas* canvas, double n) -{ - double ax, ay; - int x1, y1; - int anchor_x, anchor_y; - - g_return_if_fail(GANV_IS_CANVAS(canvas)); - g_return_if_fail(n > 1e-10); - - if (canvas->center_scroll_region) { - anchor_x = GTK_WIDGET(canvas)->allocation.width / 2; - anchor_y = GTK_WIDGET(canvas)->allocation.height / 2; - } else { - anchor_x = anchor_y = 0; - } - - /* Find the coordinates of the anchor point in units. */ - if (canvas->layout.hadjustment) { - ax - = (canvas->layout.hadjustment->value - + anchor_x) / canvas->pixels_per_unit + canvas->scroll_x1 + canvas->zoom_xofs; - } else { - ax = (0.0 + anchor_x) / canvas->pixels_per_unit + canvas->scroll_x1 + canvas->zoom_xofs; - } - if (canvas->layout.hadjustment) { - ay - = (canvas->layout.vadjustment->value - + anchor_y) / canvas->pixels_per_unit + canvas->scroll_y1 + canvas->zoom_yofs; - } else { - ay = (0.0 + anchor_y) / canvas->pixels_per_unit + canvas->scroll_y1 + canvas->zoom_yofs; - } - - /* Now calculate the new offset of the upper left corner. */ - x1 = ((ax - canvas->scroll_x1) * n) - anchor_x; - y1 = ((ay - canvas->scroll_y1) * n) - anchor_y; - - canvas->pixels_per_unit = n; - - scroll_to(canvas, x1, y1); - - ganv_canvas_request_update(canvas); - canvas->need_repick = TRUE; + return canvas->impl->center_scroll_region ? TRUE : FALSE; } /** @@ -3866,7 +3906,7 @@ ganv_canvas_scroll_to(GanvCanvas* canvas, int cx, int cy) * pixel units. **/ void -ganv_canvas_get_scroll_offsets(GanvCanvas* canvas, int* cx, int* cy) +ganv_canvas_get_scroll_offsets(const GanvCanvas* canvas, int* cx, int* cy) { g_return_if_fail(GANV_IS_CANVAS(canvas)); @@ -3902,33 +3942,26 @@ ganv_canvas_get_item_at(GanvCanvas* canvas, double x, double y) ganv_canvas_w2c(canvas, x, y, &cx, &cy); - dist = GANV_ITEM_GET_CLASS(canvas->root)->point( - canvas->root, - x - canvas->root->x, y - canvas->root->y, + dist = GANV_ITEM_GET_CLASS(canvas->impl->root)->point( + canvas->impl->root, + x - canvas->impl->root->x, y - canvas->impl->root->y, cx, cy, &item); - if ((int)(dist * canvas->pixels_per_unit + 0.5) <= canvas->close_enough) { + if ((int)(dist * canvas->impl->pixels_per_unit + 0.5) <= GANV_CLOSE_ENOUGH) { return item; } else { return NULL; } } -/* Queues an update of the canvas */ void ganv_canvas_request_update(GanvCanvas* canvas) { - GANV_CANVAS_GET_CLASS(canvas)->request_update(canvas); -} - -static void -ganv_canvas_request_update_real(GanvCanvas* canvas) -{ - if (canvas->need_update) { + if (canvas->impl->need_update) { return; } - canvas->need_update = TRUE; + canvas->impl->need_update = TRUE; if (GTK_WIDGET_MAPPED((GtkWidget*)canvas)) { add_idle(canvas); } @@ -3950,8 +3983,8 @@ static inline gboolean rect_is_visible(GanvCanvas* canvas, const IRect* r) { const IRect rect = { - (int)(canvas->layout.hadjustment->value - canvas->zoom_xofs), - (int)(canvas->layout.vadjustment->value - canvas->zoom_yofs), + (int)(canvas->layout.hadjustment->value - canvas->impl->zoom_xofs), + (int)(canvas->layout.vadjustment->value - canvas->impl->zoom_yofs), GTK_WIDGET(canvas)->allocation.width, GTK_WIDGET(canvas)->allocation.height }; @@ -3988,10 +4021,10 @@ ganv_canvas_request_redraw(GanvCanvas* canvas, int x1, int y1, int x2, int y2) IRect* r = (IRect*)g_malloc(sizeof(IRect)); *r = rect; - canvas->redraw_region = g_slist_prepend(canvas->redraw_region, r); - canvas->need_redraw = TRUE; + canvas->impl->redraw_region = g_slist_prepend(canvas->impl->redraw_region, r); + canvas->impl->need_redraw = TRUE; - if (canvas->idle_id == 0) { + if (canvas->impl->idle_id == 0) { add_idle(canvas); } } @@ -4011,12 +4044,12 @@ ganv_canvas_w2c_affine(GanvCanvas* canvas, cairo_matrix_t* matrix) g_return_if_fail(matrix != NULL); cairo_matrix_init_translate(matrix, - -canvas->scroll_x1, - -canvas->scroll_y1); + -canvas->impl->scroll_x1, + -canvas->impl->scroll_y1); cairo_matrix_scale(matrix, - canvas->pixels_per_unit, - canvas->pixels_per_unit); + canvas->impl->pixels_per_unit, + canvas->impl->pixels_per_unit); } /** @@ -4122,18 +4155,18 @@ ganv_canvas_c2w(GanvCanvas* canvas, int cx, int cy, double* wx, double* wy) **/ void ganv_canvas_window_to_world(GanvCanvas* canvas, double winx, double winy, - double* worldx, double* worldy) + double* worldx, double* worldy) { g_return_if_fail(GANV_IS_CANVAS(canvas)); if (worldx) { - *worldx = canvas->scroll_x1 + ((winx - canvas->zoom_xofs) - / canvas->pixels_per_unit); + *worldx = canvas->impl->scroll_x1 + ((winx - canvas->impl->zoom_xofs) + / canvas->impl->pixels_per_unit); } if (worldy) { - *worldy = canvas->scroll_y1 + ((winy - canvas->zoom_yofs) - / canvas->pixels_per_unit); + *worldy = canvas->impl->scroll_y1 + ((winy - canvas->impl->zoom_yofs) + / canvas->impl->pixels_per_unit); } } @@ -4149,16 +4182,16 @@ ganv_canvas_window_to_world(GanvCanvas* canvas, double winx, double winy, **/ void ganv_canvas_world_to_window(GanvCanvas* canvas, double worldx, double worldy, - double* winx, double* winy) + double* winx, double* winy) { g_return_if_fail(GANV_IS_CANVAS(canvas)); if (winx) { - *winx = (canvas->pixels_per_unit) * (worldx - canvas->scroll_x1) + canvas->zoom_xofs; + *winx = (canvas->impl->pixels_per_unit) * (worldx - canvas->impl->scroll_x1) + canvas->impl->zoom_xofs; } if (winy) { - *winy = (canvas->pixels_per_unit) * (worldy - canvas->scroll_y1) + canvas->zoom_yofs; + *winy = (canvas->impl->pixels_per_unit) * (worldy - canvas->impl->scroll_y1) + canvas->impl->zoom_yofs; } } diff --git a/src/ganv-private.h b/src/ganv-private.h index 368e056..040e335 100644 --- a/src/ganv-private.h +++ b/src/ganv-private.h @@ -26,6 +26,8 @@ extern "C" { #include "ganv/text.h" #include "ganv/types.h" +#define GANV_CLOSE_ENOUGH 1 + extern guint signal_moved; /* Box */ @@ -199,6 +201,9 @@ ganv_canvas_port_event(GanvCanvas* canvas, GdkEvent* event); void +ganv_canvas_contents_changed(GanvCanvas* canvas); + +void ganv_item_i2w_offset(GanvItem* item, double* px, double* py); void @@ -216,6 +221,24 @@ ganv_canvas_request_update(GanvCanvas* canvas); int ganv_canvas_emit_event(GanvCanvas* canvas, GdkEvent* event); +void +ganv_canvas_set_need_repick(GanvCanvas* canvas); + +void +ganv_canvas_forget_item(GanvCanvas* canvas, GanvItem* item); + +void +ganv_canvas_grab_focus(GanvCanvas* canvas, GanvItem* item); + +void +ganv_canvas_get_zoom_offsets(GanvCanvas* canvas, int* x, int* y); + +int +ganv_canvas_grab_item(GanvItem* item, guint event_mask, GdkCursor* cursor, guint32 etime); + +void +ganv_canvas_ungrab_item(GanvItem* item, guint32 etime); + /* For use only by item type implementations. Request that the canvas * eventually redraw the specified region, specified in canvas pixel * coordinates. The region contains (x1, y1) but not (x2, y2). diff --git a/src/group.c b/src/group.c index 58f5007..607adcf 100644 --- a/src/group.c +++ b/src/group.c @@ -242,10 +242,10 @@ ganv_group_point(GanvItem* item, double x, double y, int cx, int cy, group = GANV_GROUP(item); - x1 = cx - item->canvas->close_enough; - y1 = cy - item->canvas->close_enough; - x2 = cx + item->canvas->close_enough; - y2 = cy + item->canvas->close_enough; + x1 = cx - GANV_CLOSE_ENOUGH; + y1 = cy - GANV_CLOSE_ENOUGH; + x2 = cx + GANV_CLOSE_ENOUGH; + y2 = cy + GANV_CLOSE_ENOUGH; best = 0.0; *actual_item = NULL; @@ -278,8 +278,8 @@ ganv_group_point(GanvItem* item, double x, double y, int cx, int cy, if (has_point && point_item - && ((int)(dist * item->canvas->pixels_per_unit + 0.5) - <= item->canvas->close_enough)) { + && ((int)(dist * ganv_canvas_get_zoom(item->canvas) + 0.5) + <= GANV_CLOSE_ENOUGH)) { best = dist; *actual_item = point_item; } @@ -129,7 +129,7 @@ item_post_create_setup(GanvItem* item) ganv_canvas_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1, item->y2 + 1); - item->canvas->need_repick = TRUE; + ganv_canvas_set_need_repick(item->canvas); } static void @@ -230,8 +230,9 @@ static void redraw_if_visible(GanvItem* item) { if (item->object.flags & GANV_ITEM_VISIBLE) { - ganv_canvas_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1, - item->y2 + 1); + ganv_canvas_request_redraw(item->canvas, + item->x1, item->y1, + item->x2 + 1, item->y2 + 1); } } @@ -247,27 +248,7 @@ ganv_item_dispose(GObject* object) if (item->canvas) { redraw_if_visible(item); - } - - /* Make the canvas forget about us */ - - if (item->canvas && item == item->canvas->current_item) { - item->canvas->current_item = NULL; - item->canvas->need_repick = TRUE; - } - - if (item->canvas && item == item->canvas->new_current_item) { - item->canvas->new_current_item = NULL; - item->canvas->need_repick = TRUE; - } - - if (item->canvas && item == item->canvas->grabbed_item) { - item->canvas->grabbed_item = NULL; - gdk_pointer_ungrab(GDK_CURRENT_TIME); - } - - if (item->canvas && item == item->canvas->focused_item) { - item->canvas->focused_item = NULL; + ganv_canvas_forget_item(item->canvas, item); } /* Normal destroy stuff */ @@ -402,7 +383,7 @@ ganv_item_set_valist(GanvItem* item, const gchar* first_arg_name, va_list args) g_object_set_valist(G_OBJECT(item), first_arg_name, args); - item->canvas->need_repick = TRUE; + ganv_canvas_set_need_repick(item->canvas); } void @@ -434,7 +415,7 @@ ganv_item_move(GanvItem* item, double dx, double dy) item->y += dy; ganv_item_request_update(item); - item->canvas->need_repick = TRUE; + ganv_canvas_set_need_repick(item->canvas); } /** @@ -450,9 +431,10 @@ ganv_item_show(GanvItem* item) if (!(item->object.flags & GANV_ITEM_VISIBLE)) { item->object.flags |= GANV_ITEM_VISIBLE; - ganv_canvas_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1, - item->y2 + 1); - item->canvas->need_repick = TRUE; + ganv_canvas_request_redraw(item->canvas, + item->x1, item->y1, + item->x2 + 1, item->y2 + 1); + ganv_canvas_set_need_repick(item->canvas); } } @@ -470,86 +452,13 @@ ganv_item_hide(GanvItem* item) if (item->object.flags & GANV_ITEM_VISIBLE) { item->object.flags &= ~GANV_ITEM_VISIBLE; - ganv_canvas_request_redraw(item->canvas, item->x1, item->y1, item->x2 + 1, - item->y2 + 1); - item->canvas->need_repick = TRUE; + ganv_canvas_request_redraw(item->canvas, + item->x1, item->y1, + item->x2 + 1, item->y2 + 1); + ganv_canvas_set_need_repick(item->canvas); } } -/** - * ganv_item_grab: - * @item: A canvas item. - * @event_mask: Mask of events that will be sent to this item. - * @cursor: If non-NULL, the cursor that will be used while the grab is active. - * @etime: The timestamp required for grabbing the mouse, or GDK_CURRENT_TIME. - * - * Specifies that all events that match the specified event mask should be sent - * to the specified item, and also grabs the mouse by calling - * gdk_pointer_grab(). The event mask is also used when grabbing the pointer. - * If @cursor is not NULL, then that cursor is used while the grab is active. - * The @etime parameter is the timestamp required for grabbing the mouse. - * - * Return value: If an item was already grabbed, it returns %GDK_GRAB_ALREADY_GRABBED. If - * the specified item was hidden by calling ganv_item_hide(), then it - * returns %GDK_GRAB_NOT_VIEWABLE. Else, it returns the result of calling - * gdk_pointer_grab(). - **/ -int -ganv_item_grab(GanvItem* item, guint event_mask, GdkCursor* cursor, guint32 etime) -{ - int retval; - - g_return_val_if_fail(GANV_IS_ITEM(item), GDK_GRAB_NOT_VIEWABLE); - g_return_val_if_fail(GTK_WIDGET_MAPPED(item->canvas), GDK_GRAB_NOT_VIEWABLE); - - if (item->canvas->grabbed_item) { - return GDK_GRAB_ALREADY_GRABBED; - } - - if (!(item->object.flags & GANV_ITEM_VISIBLE)) { - return GDK_GRAB_NOT_VIEWABLE; - } - - retval = gdk_pointer_grab(item->canvas->layout.bin_window, - FALSE, - event_mask, - NULL, - cursor, - etime); - - if (retval != GDK_GRAB_SUCCESS) { - return retval; - } - - item->canvas->grabbed_item = item; - item->canvas->grabbed_event_mask = event_mask; - item->canvas->current_item = item; /* So that events go to the grabbed item */ - - return retval; -} - -/** - * ganv_item_ungrab: - * @item: A canvas item that holds a grab. - * @etime: The timestamp for ungrabbing the mouse. - * - * Ungrabs the item, which must have been grabbed in the canvas, and ungrabs the - * mouse. - **/ -void -ganv_item_ungrab(GanvItem* item, guint32 etime) -{ - g_return_if_fail(GANV_IS_ITEM(item)); - - if (item->canvas->grabbed_item != item) { - return; - } - - item->canvas->grabbed_item = NULL; - - gdk_pointer_ungrab(etime); -} - void ganv_item_i2w_offset(GanvItem* item, double* px, double* py) { @@ -632,34 +541,7 @@ ganv_item_w2i(GanvItem* item, double* x, double* y) void ganv_item_grab_focus(GanvItem* item) { - GanvItem* focused_item; - GdkEvent ev; - - g_return_if_fail(GANV_IS_ITEM(item)); - g_return_if_fail(GTK_WIDGET_CAN_FOCUS(GTK_WIDGET(item->canvas))); - - focused_item = item->canvas->focused_item; - - if (focused_item) { - ev.focus_change.type = GDK_FOCUS_CHANGE; - ev.focus_change.window = GTK_LAYOUT(item->canvas)->bin_window; - ev.focus_change.send_event = FALSE; - ev.focus_change.in = FALSE; - - ganv_canvas_emit_event(item->canvas, &ev); - } - - item->canvas->focused_item = item; - gtk_widget_grab_focus(GTK_WIDGET(item->canvas)); - - if (focused_item) { - ev.focus_change.type = GDK_FOCUS_CHANGE; - ev.focus_change.window = GTK_LAYOUT(item->canvas)->bin_window; - ev.focus_change.send_event = FALSE; - ev.focus_change.in = TRUE; - - ganv_canvas_emit_event(item->canvas, &ev); - } + ganv_canvas_grab_focus(item->canvas, item); } void diff --git a/src/module.c b/src/module.c index 779d26b..5434fc8 100644 --- a/src/module.c +++ b/src/module.c @@ -152,7 +152,7 @@ measure(GanvModule* module, Metrics* m) GanvText* canvas_title = GANV_NODE(module)->impl->label; GanvModuleImpl* impl = module->impl; - if (canvas->direction == GANV_DIRECTION_DOWN) { + if (ganv_canvas_get_direction(canvas) == GANV_DIRECTION_DOWN) { static const double PAD = 2.0; double contents_width = PAD; @@ -430,7 +430,7 @@ layout(GanvNode* self) ganv_box_set_width(GANV_BOX(module), label_w + (MODULE_LABEL_PAD * 2.0)); ganv_box_set_height(GANV_BOX(module), label_h); - switch (canvas->direction) { + switch (ganv_canvas_get_direction(canvas)) { case GANV_DIRECTION_RIGHT: resize_right(module); break; @@ -481,7 +481,7 @@ ganv_module_add_port(GanvModule* module, impl->must_resize = TRUE; g_ptr_array_add(impl->ports, port); - place_title(module, canvas->direction); + place_title(module, ganv_canvas_get_direction(canvas)); ganv_item_request_update(GANV_ITEM(module)); } @@ -236,7 +236,7 @@ ganv_node_default_tail_vector(const GanvNode* self, *x = GANV_ITEM(self)->x; *y = GANV_ITEM(self)->y; - switch (canvas->direction) { + switch (ganv_canvas_get_direction(canvas)) { case GANV_DIRECTION_RIGHT: *dx = 1.0; *dy = 0.0; @@ -263,7 +263,7 @@ ganv_node_default_head_vector(const GanvNode* self, *x = GANV_ITEM(self)->x; *y = GANV_ITEM(self)->y; - switch (canvas->direction) { + switch (ganv_canvas_get_direction(canvas)) { case GANV_DIRECTION_RIGHT: *dx = -1.0; *dy = 0.0; @@ -440,8 +440,8 @@ ganv_node_default_event(GanvItem* item, drag_start_y = event->button.y; last_x = event->button.x; last_y = event->button.y; - if (!canvas->locked && node->impl->draggable && event->button.button == 1) { - ganv_item_grab( + if (!ganv_canvas_get_locked(canvas) && node->impl->draggable && event->button.button == 1) { + ganv_canvas_grab_item( GANV_ITEM(node), GDK_POINTER_MOTION_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_PRESS_MASK, ganv_canvas_get_move_cursor(canvas), @@ -456,7 +456,7 @@ ganv_node_default_event(GanvItem* item, if (dragging) { gboolean selected; g_object_get(G_OBJECT(node), "selected", &selected, NULL); - ganv_item_ungrab(GANV_ITEM(node), event->button.time); + ganv_canvas_ungrab_item(GANV_ITEM(node), event->button.time); node->impl->grabbed = FALSE; ganv_canvas_contents_changed(canvas); dragging = FALSE; @@ -143,7 +143,7 @@ ganv_port_draw(GanvItem* item, GANV_ITEM_GET_CLASS(rect)->draw(rect, cr, cx, cy, width, height); } - if (canvas->direction == GANV_DIRECTION_DOWN || + if (ganv_canvas_get_direction(canvas) == GANV_DIRECTION_DOWN || !GANV_NODE(port)->impl->show_label) { return; } @@ -175,7 +175,7 @@ ganv_port_tail_vector(const GanvNode* self, const double px = item->x; const double py = item->y; - switch (canvas->direction) { + switch (ganv_canvas_get_direction(canvas)) { case GANV_DIRECTION_RIGHT: *x = px + ganv_box_get_width(&port->box); *y = py + ganv_box_get_height(&port->box) / 2.0; @@ -208,7 +208,7 @@ ganv_port_head_vector(const GanvNode* self, const double px = item->x; const double py = item->y; - switch (canvas->direction) { + switch (ganv_canvas_get_direction(canvas)) { case GANV_DIRECTION_RIGHT: *x = px; *y = py + ganv_box_get_height(&port->box) / 2.0; @@ -234,7 +234,7 @@ ganv_port_place_value_label(GanvPort* port) GanvCanvas* canvas = GANV_CANVAS(GANV_ITEM(port)->canvas); const double port_w = ganv_box_get_width(&port->box); const double label_w = control->label->impl->coords.width; - if (canvas->direction == GANV_DIRECTION_RIGHT) { + if (ganv_canvas_get_direction(canvas) == GANV_DIRECTION_RIGHT) { ganv_item_set(GANV_ITEM(control->label), "x", port_w - label_w - PORT_LABEL_HPAD, "y", PORT_LABEL_VPAD, @@ -417,7 +417,7 @@ ganv_port_new(GanvModule* module, node->impl->border_width = 1.0; GanvCanvas* canvas = GANV_CANVAS(GANV_ITEM(port)->canvas); - ganv_port_set_direction(port, canvas->direction); + ganv_port_set_direction(port, ganv_canvas_get_direction(canvas)); return port; } @@ -638,7 +638,7 @@ ganv_port_get_natural_width(const GanvPort* port) GanvCanvas* const canvas = GANV_CANVAS(GANV_ITEM(port)->canvas); GanvText* const label = port->box.node.impl->label; double w = 0.0; - if (canvas->direction == GANV_DIRECTION_DOWN) { + if (ganv_canvas_get_direction(canvas) == GANV_DIRECTION_DOWN) { w = ganv_module_get_empty_port_breadth(ganv_port_get_module(port)); } else if (label && (GANV_ITEM(label)->object.flags & GANV_ITEM_VISIBLE)) { double label_w; diff --git a/src/widget.c b/src/widget.c index 63c1dfd..1442237 100644 --- a/src/widget.c +++ b/src/widget.c @@ -25,6 +25,7 @@ #include "ganv/widget.h" #include "./gettext.h" +#include "./ganv-private.h" G_DEFINE_TYPE(GanvWidget, ganv_widget, GANV_TYPE_ITEM) @@ -130,10 +131,12 @@ recalc_bounds(GanvWidget* witem) item->x2 = witem->cx + witem->cwidth; item->y2 = witem->cy + witem->cheight; + int zoom_xofs, zoom_yofs; + ganv_canvas_get_zoom_offsets(item->canvas, &zoom_xofs, &zoom_yofs); if (witem->widget) { gtk_layout_move(GTK_LAYOUT(item->canvas), witem->widget, - witem->cx + item->canvas->zoom_xofs, - witem->cy + item->canvas->zoom_yofs); + witem->cx + zoom_xofs, + witem->cy + zoom_yofs); } } @@ -171,9 +174,12 @@ ganv_widget_set_property(GObject* object, witem->destroy_id = g_signal_connect(obj, "destroy", G_CALLBACK(do_destroy), witem); + int zoom_xofs, zoom_yofs; + ganv_canvas_get_zoom_offsets(item->canvas, &zoom_xofs, &zoom_yofs); + gtk_layout_put(GTK_LAYOUT(item->canvas), witem->widget, - witem->cx + item->canvas->zoom_xofs, - witem->cy + item->canvas->zoom_yofs); + witem->cx + zoom_xofs, + witem->cy + zoom_yofs); } update = TRUE; @@ -291,12 +297,13 @@ ganv_widget_update(GanvItem* item, int flags) } if (witem->widget) { + const double pixels_per_unit = ganv_canvas_get_zoom(item->canvas); if (witem->size_pixels) { witem->cwidth = (int)(witem->width + 0.5); witem->cheight = (int)(witem->height + 0.5); } else { - witem->cwidth = (int)(witem->width * item->canvas->pixels_per_unit + 0.5); - witem->cheight = (int)(witem->height * item->canvas->pixels_per_unit + 0.5); + witem->cwidth = (int)(witem->width * pixels_per_unit + 0.5); + witem->cheight = (int)(witem->height * pixels_per_unit + 0.5); } gtk_widget_set_size_request(witem->widget, witem->cwidth, witem->cheight); @@ -332,8 +339,10 @@ ganv_widget_point(GanvItem* item, double x, double y, double x1, y1; ganv_canvas_c2w(item->canvas, witem->cx, witem->cy, &x1, &y1); - double x2 = x1 + (witem->cwidth - 1) / item->canvas->pixels_per_unit; - double y2 = y1 + (witem->cheight - 1) / item->canvas->pixels_per_unit; + const double pixels_per_unit = ganv_canvas_get_zoom(item->canvas); + + double x2 = x1 + (witem->cwidth - 1) / pixels_per_unit; + double y2 = y1 + (witem->cheight - 1) / pixels_per_unit; /* Is point inside widget bounds? */ |