31 #include "display/sp-canvas.h"
32 #include "display/sp-canvas-group.h"
53 // The canvas stores a 2D array of ints, each representing a TILE_SIZExTILE_SIZE pixels tile.
69      * Adds an item to a canvas group.
74      * Removes an item from a canvas group.
95      * Update handler for canvas groups.
100      * Point handler for canvas groups.
105      * Renders all visible canvas group items in buf rectangle.
131 GdkWindow *getWindow(SPCanvas *canvas)
133     return gtk_widget_get_window(reinterpret_cast<GtkWidget *>(canvas));
253     item->canvas = item->parent->canvas;
276             item->canvas->requestRedraw((int)(item->x1 - 1), (int)(item->y1 -1), (int)(item->x2 + 1), (int)(item->y2 + 1));
312       if (item == item->canvas->_current_item) {
313           item->canvas->_current_item = NULL;
314           item->canvas->_need_repick = TRUE;
317       if (item == item->canvas->_new_current_item) {
318           item->canvas->_new_current_item = NULL;
319           item->canvas->_need_repick = TRUE;
322       if (item == item->canvas->_grabbed_item) {
323           item->canvas->_grabbed_item = NULL;
334       if (item == item->canvas->_focused_item) {
335           item->canvas->_focused_item = NULL;
421  * @item: A canvas item.
433             item->canvas->requestUpdate();
437     item->canvas->_need_repick = TRUE;
443  * @param item A canvas item.
470     item->canvas->_need_repick = TRUE;
483     item->canvas->_need_repick = TRUE;
491  * @param item A canvas item.
519     item->canvas->_need_repick = TRUE;
532     item->canvas->_need_repick = TRUE;
560         item->canvas->requestRedraw((int)(item->x1), (int)(item->y1), (int)(item->x2 + 1), (int)(item->y2 + 1));
561         item->canvas->_need_repick = TRUE;
585         item->canvas->requestRedraw((int)item->x1, (int)item->y1, (int)(item->x2 + 1), (int)(item->y2 + 1));
586         item->canvas->_need_repick = TRUE;
593  * \pre !canvas->grabbed_item && item->flags & SP_CANVAS_ITEM_VISIBLE
599     g_return_val_if_fail (gtk_widget_get_mapped (GTK_WIDGET (item->canvas)), -1);
601     if (item->canvas->_grabbed_item) {
624                     getWindow(item->canvas),
631     gdk_pointer_grab( getWindow(item->canvas), FALSE,
636     item->canvas->_grabbed_item = item;
637     item->canvas->_grabbed_event_mask = event_mask;
638     item->canvas->_current_item = item; // So that events go to the grabbed item
644  * Ungrabs the item, which must have been grabbed in the canvas, and ungrabs the
647  * @param item A canvas item that holds a grab.
655     if (item->canvas->_grabbed_item != item) {
659     item->canvas->_grabbed_item = NULL;
704  * Requests that the canvas queue an update for the specified item.
721         item->canvas->requestUpdate();
811     int x1 = (int)(x - item->canvas->_close_enough);
812     int y1 = (int)(y - item->canvas->_close_enough);
813     int x2 = (int)(x + item->canvas->_close_enough);
814     int y2 = (int)(y + item->canvas->_close_enough);
840             if (pickable && point_item && ((int) (dist + 0.5) <= item->canvas->_close_enough)) {
939 static void sp_canvas_init(SPCanvas *canvas)
941     gtk_widget_set_has_window (GTK_WIDGET (canvas), TRUE);
942     gtk_widget_set_can_focus (GTK_WIDGET (canvas), TRUE);
944     canvas->_pick_event.type = GDK_LEAVE_NOTIFY;
945     canvas->_pick_event.crossing.x = 0;
946     canvas->_pick_event.crossing.y = 0;
949     canvas->_root = SP_CANVAS_ITEM(g_object_new(SP_TYPE_CANVAS_GROUP, NULL));
950     canvas->_root->canvas = canvas;
952     g_object_ref (canvas->_root);
953     g_object_ref_sink (canvas->_root);
955     canvas->_need_repick = TRUE;
957     // See comment at in sp-canvas.h.
958     canvas->_gen_all_enter_events = false;
960     canvas->_drawing_disabled = false;
962     canvas->_backing_store = NULL;
963     canvas->_clean_region = cairo_region_create();
964     canvas->_background = cairo_pattern_create_rgb(1, 1, 1);
965     canvas->_background_is_checkerboard = false;
967     canvas->_forced_redraw_count = 0;
968     canvas->_forced_redraw_limit = -1;
971     canvas->_enable_cms_display_adj = false;
972     new (&canvas->_cms_key) Glib::ustring("");
996     SPCanvas *canvas = SP_CANVAS(object);
998     if (canvas->_root) {
999         g_object_unref (canvas->_root);
1000         canvas->_root = NULL;
1002     if (canvas->_backing_store) {
1003         cairo_surface_destroy(canvas->_backing_store);
1004         canvas->_backing_store = NULL;
1006     if (canvas->_clean_region) {
1007         cairo_region_destroy(canvas->_clean_region);
1008         canvas->_clean_region = NULL;
1010     if (canvas->_background) {
1011         cairo_pattern_destroy(canvas->_background);
1012         canvas->_background = NULL;
1015     canvas->shutdownTransients();
1017     canvas->_cms_key.~ustring();
1039     SPCanvas *canvas = SP_CANVAS(g_object_new(SP_TYPE_CANVAS, NULL));
1040     return GTK_WIDGET(canvas);
1106     SPCanvas *canvas = SP_CANVAS (widget);
1108     canvas->_current_item = NULL;
1109     canvas->_grabbed_item = NULL;
1110     canvas->_focused_item = NULL;
1112     canvas->shutdownTransients();
1146     SPCanvas *canvas = SP_CANVAS (widget);
1151 //    Geom::IntRect old_area = Geom::IntRect::from_xywh(canvas->_x0, canvas->_y0,
1154     Geom::IntRect new_area = Geom::IntRect::from_xywh(canvas->_x0, canvas->_y0,
1160     if (canvas->_backing_store) {
1162         cairo_translate(cr, -canvas->_x0, -canvas->_y0);
1164         cairo_set_source(cr, canvas->_background);
1166         cairo_set_source_surface(cr, canvas->_backing_store, canvas->_x0, canvas->_y0);
1169         cairo_surface_destroy(canvas->_backing_store);
1171     canvas->_backing_store = new_backing_store;
1174     cairo_rectangle_int_t crect = { canvas->_x0, canvas->_y0, allocation->width, allocation->height };
1175     cairo_region_intersect_rectangle(canvas->_clean_region, &crect);
1179     if (SP_CANVAS_ITEM_GET_CLASS (canvas->_root)->viewbox_changed)
1180         SP_CANVAS_ITEM_GET_CLASS (canvas->_root)->viewbox_changed (canvas->_root, new_area);
1188     canvas->addIdle();
1264     // canvas->current_item becomes NULL in some cases under Win32
1305     if (!_root) // canvas may have already be destroyed by closing desktop during interrupted display!
1313         // less like X pointer grabbing for canvas items.
1321     // Save the event in the canvas.  This is used to synthesize enter and
1436     SPCanvas *canvas = SP_CANVAS (widget);
1442     if (!canvas->_grabbed_item &&
1443         event->window != getWindow(canvas))
1474         canvas->_state = event->state;
1475         canvas->pickCurrentItem(reinterpret_cast<GdkEvent *>(event));
1476         canvas->_state ^= mask;
1477         retval = canvas->emitEvent((GdkEvent *) event);
1484         canvas->_state = event->state;
1485         retval = canvas->emitEvent((GdkEvent *) event);
1487         canvas->_state = event->state;
1488         canvas->pickCurrentItem(reinterpret_cast<GdkEvent *>(event));
1519     SPCanvas *canvas = SP_CANVAS (widget);
1523     if (event->window != getWindow(canvas)) {
1527     if (canvas->_root == NULL) // canvas being deleted
1530     canvas->_state = event->state;
1531     canvas->pickCurrentItem(reinterpret_cast<GdkEvent *>(event));
1532     status = canvas->emitEvent(reinterpret_cast<GdkEvent *>(event));
1660         r.x = this_rect.x0 - setup->canvas->x0;
1661         r.y = this_rect.y0 - setup->canvas->y0;
1665         GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(setup->canvas));
1791     SPCanvas *canvas = SP_CANVAS(widget);
1796     cairo_set_source_surface(cr, canvas->_backing_store, 0, 0);
1804         Geom::Rect dr = Geom::Rect::from_xywh(rectangle.x + canvas->_x0, rectangle.y + canvas->_y0,
1811     cairo_region_subtract(dirty_region, canvas->_clean_region);
1815         canvas->addIdle();
1844     SPCanvas *canvas = SP_CANVAS (widget);
1846     if (event->window != getWindow(canvas)) {
1850     canvas->_state = event->state;
1851     return canvas->pickCurrentItem(reinterpret_cast<GdkEvent *>(event));
1858     SPCanvas *canvas = SP_CANVAS (widget);
1860     if (canvas->_focused_item) {
1861         return canvas->emitEvent(reinterpret_cast<GdkEvent *>(event));
1869     SPCanvas *canvas = SP_CANVAS(widget);
1871     if (canvas->_focused_item) {
1872         return canvas->emitEvent(reinterpret_cast<GdkEvent *>(event));
1911     if (!_root) { // canvas may have already be destroyed by closing desktop during interrupted display!
1940     SPCanvas *canvas = SP_CANVAS (data);
1941     int const ret = canvas->doUpdate();
1944         canvas->_idle_id = 0;
1972     int ix = (int) round(cx); // ix and iy are the new canvas coordinates (integer screen pixels)
1975     int dy = iy - _y0; // canvas w.r.t its previous position
2086  * Sets world coordinates from win and canvas.
2088 void sp_canvas_window_to_world(SPCanvas const *canvas, double winx, double winy, double *worldx, double *worldy)
2090     g_return_if_fail (canvas != NULL);
2091     g_return_if_fail (SP_IS_CANVAS (canvas));
2093     if (worldx) *worldx = canvas->_x0 + winx;
2094     if (worldy) *worldy = canvas->_y0 + winy;
2098  * Sets win coordinates from world and canvas.
2100 void sp_canvas_world_to_window(SPCanvas const *canvas, double worldx, double worldy, double *winx, double *winy)
2102     g_return_if_fail (canvas != NULL);
2103     g_return_if_fail (SP_IS_CANVAS (canvas));
2105     if (winx) *winx = worldx - canvas->_x0;
2106     if (winy) *winy = worldy - canvas->_y0;
2112 Geom::Point sp_canvas_window_to_world(SPCanvas const *canvas, Geom::Point const win)
2114     g_assert (canvas != NULL);
2115     g_assert (SP_IS_CANVAS (canvas));
2117     return Geom::Point(canvas->_x0 + win[0], canvas->_y0 + win[1]);
2123 Geom::Point sp_canvas_world_to_window(SPCanvas const *canvas, Geom::Point const world)
2125     g_assert (canvas != NULL);
2126     g_assert (SP_IS_CANVAS (canvas));
2128     return Geom::Point(world[0] - canvas->_x0, world[1] - canvas->_y0);
2134 bool sp_canvas_world_pt_inside_window(SPCanvas const *canvas, Geom::Point const &world)
2138     g_assert( canvas != NULL );
2139     g_assert(SP_IS_CANVAS(canvas));
2141     GtkWidget *w = GTK_WIDGET(canvas);
2144     return ( ( canvas->_x0 <= world[Geom::X] )  &&
2145              ( canvas->_y0 <= world[Geom::Y] )  &&
2146              ( world[Geom::X] < canvas->_x0 + allocation.width )  &&
2147              ( world[Geom::Y] < canvas->_y0 + allocation.height ) );
2151  * Return canvas window coordinates as Geom::Rect.
2163  * Return canvas window coordinates as integer rectangle.

Indexes created Tue Jul 24 14:28:13 CEST 2018