void wxRegionIterator::CreateRects( const wxRegion& region ) { wxDELETEA(m_rects); m_numRects = 0; GdkRegion *gdkregion = region.GetRegion(); if (!gdkregion) return; GdkRectangle *gdkrects = NULL; gint numRects = 0; gdk_region_get_rectangles( gdkregion, &gdkrects, &numRects ); m_numRects = numRects; if (numRects) { m_rects = new wxRect[m_numRects]; for (size_t i=0; i < m_numRects; ++i) { GdkRectangle &gr = gdkrects[i]; wxRect &wr = m_rects[i]; wr.x = gr.x; wr.y = gr.y; wr.width = gr.width; wr.height = gr.height; } } g_free( gdkrects ); }
static gboolean ctk_banner_expose_event( GtkWidget *widget, GdkEventExpose *event ) { CtkBanner *ctk_banner = CTK_BANNER(widget); GdkRectangle *rects; int n_rects; int i; /* copy the backing pixbuf into the exposed portion of the window */ gdk_region_get_rectangles(event->region, &rects, &n_rects); for (i = 0; i < n_rects; i++) { gdk_draw_pixbuf(widget->window, widget->style->fg_gc[GTK_STATE_NORMAL], ctk_banner->back.pixbuf, rects[i].x, rects[i].y, rects[i].x, rects[i].y, rects[i].width, rects[i].height, GDK_RGB_DITHER_NORMAL, 0, 0); } g_free(rects); return FALSE; }
/*! \brief Redraws the view when widget is exposed. * \par Function Description * It redraws the preview pixmap every time the widget is exposed. * * \param [in] widget The preview widget. * \param [in] event The event structure. * \param [in] user_data Unused user data. * \returns FALSE to propagate the event further. */ static gboolean preview_callback_expose (GtkWidget *widget, GdkEventExpose *event, gpointer user_data) { Preview *preview = PREVIEW (widget); GSCHEM_TOPLEVEL *preview_w_current = preview->preview_w_current; GdkRectangle *rectangles; int n_rectangles; cairo_t *save_cr; PangoLayout *save_pl; save_cr = preview_w_current->cr; save_pl = preview_w_current->pl; preview_w_current->cr = gdk_cairo_create (widget->window); preview_w_current->pl = pango_cairo_create_layout (preview_w_current->cr); gdk_region_get_rectangles (event->region, &rectangles, &n_rectangles); o_redraw_rects (preview_w_current, rectangles, n_rectangles); g_free (rectangles); g_object_unref (preview_w_current->pl); cairo_destroy (preview_w_current->cr); preview_w_current->cr = save_cr; preview_w_current->pl = save_pl; return FALSE; }
void wxRegionIterator::CreateRects( const wxRegion& region ) { wxDELETEA(m_rects); m_numRects = 0; #ifdef __WXGTK3__ cairo_region_t* cairoRegion = region.GetRegion(); if (cairoRegion == NULL) return; m_numRects = cairo_region_num_rectangles(cairoRegion); if (m_numRects) { m_rects = new wxRect[m_numRects]; for (int i = 0; i < m_numRects; i++) { GdkRectangle gr; cairo_region_get_rectangle(cairoRegion, i, &gr); wxRect &wr = m_rects[i]; wr.x = gr.x; wr.y = gr.y; wr.width = gr.width; wr.height = gr.height; } } #else GdkRegion *gdkregion = region.GetRegion(); if (!gdkregion) return; GdkRectangle* gdkrects; gdk_region_get_rectangles(gdkregion, &gdkrects, &m_numRects); if (m_numRects) { m_rects = new wxRect[m_numRects]; for (int i = 0; i < m_numRects; ++i) { GdkRectangle &gr = gdkrects[i]; wxRect &wr = m_rects[i]; wr.x = gr.x; wr.y = gr.y; wr.width = gr.width; wr.height = gr.height; } } g_free( gdkrects ); #endif }
static VALUE rg_rectangles(VALUE self) { GdkRectangle* rectangles; gint n_rect, i; VALUE ary; gdk_region_get_rectangles(_SELF(self), &rectangles, &n_rect); ary = rb_ary_new2(n_rect); for (i = 0; i < n_rect; i++) { rb_ary_push(ary, BOXED2RVAL(&rectangles[i], GDK_TYPE_RECTANGLE)); } g_free(rectangles); return ary; }
static gboolean expose_event (GtkWidget * widget, GdkEventExpose* event) { if (PRIV (widget)->view) { cairo_rectangle_list_t region = { CAIRO_STATUS_SUCCESS, NULL, 0 }; cairo_rectangle_t area = { 0.0, 0.0, event->area.width, event->area.height }; GdkRectangle * rectangles = NULL; cairo_t * context = gdk_cairo_create (event->window); size_t iter; gdk_region_get_rectangles (event->region, &rectangles, ®ion.num_rectangles); region.rectangles = g_slice_alloc (sizeof (*region.rectangles) * region.num_rectangles); for (iter = 0; iter < region.num_rectangles; iter++) { region.rectangles[iter].x = rectangles[iter].x - widget->allocation.x; region.rectangles[iter].y = rectangles[iter].y - widget->allocation.y; region.rectangles[iter].width = rectangles[iter].width - widget->allocation.x; region.rectangles[iter].height = rectangles[iter].height - widget->allocation.y; } g_free (rectangles); cairo_save (context); gtk_mvc_view_paint (PRIV (widget)->view, context, &area, ®ion); g_slice_free1 (sizeof (*region.rectangles) * region.num_rectangles, region.rectangles); cairo_restore (context); cairo_destroy (context); } return FALSE; }
gboolean gimp_overlay_child_damage (GimpOverlayBox *box, GimpOverlayChild *child, GdkEventExpose *event) { GtkWidget *widget; g_return_val_if_fail (GIMP_IS_OVERLAY_BOX (box), FALSE); g_return_val_if_fail (child != NULL, FALSE); g_return_val_if_fail (event != NULL, FALSE); widget = GTK_WIDGET (box); if (event->window == child->window) { GdkRectangle *rects; gint n_rects; gint i; gdk_region_get_rectangles (event->region, &rects, &n_rects); for (i = 0; i < n_rects; i++) { GdkRectangle bounds; gimp_overlay_child_transform_bounds (child, &rects[i], &bounds); gdk_window_invalidate_rect (gtk_widget_get_window (widget), &bounds, FALSE); } g_free (rects); return TRUE; } return FALSE; }
static void image_select_shape (gint32 image, GdkRegion *shape) { GdkRectangle *rects; gint num_rects; gint i; gimp_selection_none (image); gdk_region_get_rectangles (shape, &rects, &num_rects); for (i = 0; i < num_rects; i++) { gimp_rect_select (image, rects[i].x, rects[i].y, rects[i].width, rects[i].height, GIMP_CHANNEL_OP_ADD, FALSE, 0); } g_free (rects); gimp_selection_invert (image); }
/* Expose event handler for the image view. First we process the whole dirty * region by drawing a non-interpolated version, which is "instantaneous", and * we do this synchronously. Then, if we are set to use interpolation, we queue * an idle handler to handle interpolated drawing there. */ static gboolean image_view_expose_event (GtkWidget *widget, GdkEventExpose *event) { ImageView *view; GdkRectangle *rects; gint n_rects; int i; g_return_val_if_fail (widget != NULL, FALSE); g_return_val_if_fail (IS_IMAGE_VIEW (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); view = IMAGE_VIEW (widget); gdk_region_get_rectangles (event->region, &rects, &n_rects); for (i = 0; i < n_rects; i++) request_paint_area (view, rects + i); g_free (rects); return TRUE; }
void FloatingWindow::display(bool startup) // Does the bookkeeping necessary for displaying the floating box. // startup: whether the box is started at program startup. { // Settings. extern Settings *settings; // The parameters of all the windows. WindowData window_parameters(false); // Clear the new window's position. my_gdk_rectangle.x = 0; my_gdk_rectangle.y = 0; my_gdk_rectangle.width = 0; my_gdk_rectangle.height = 0; // At program startup extract the position and size of the window from the general configuration. // It does not matter whether the space for the window is already taken up by another window, // because the user wishes to use the coordinates that he has set for this window. for (unsigned int i = 0; i < window_parameters.widths.size(); i++) { if ((window_parameters.ids[i] == window_id) && (window_parameters.titles[i] == title) && startup) { my_gdk_rectangle.x = window_parameters.x_positions[i]; my_gdk_rectangle.y = window_parameters.y_positions[i]; my_gdk_rectangle.width = window_parameters.widths[i]; my_gdk_rectangle.height = window_parameters.heights[i]; } } // Reject zero width and zero height values on startup. if ((my_gdk_rectangle.width == 0) || (my_gdk_rectangle.height == 0)) startup = false; // When a new window needs to be allocated, there are a few steps to be taken. if (!startup) { // Step 1: The area rectangle where the window should fit in is defined. GdkRectangle area_rectangle; area_rectangle.x = 0; area_rectangle.y = 0; area_rectangle.width = 0; area_rectangle.height = 0; { guint width, height; gtk_layout_get_size (GTK_LAYOUT (layout), &width, &height); area_rectangle.width = width; area_rectangle.height = height; } // Step 2: An available region is made of that whole area. GdkRegion *available_region = gdk_region_rectangle(&area_rectangle); // Step 3: The regions of each of the open windows is substracted from the available region. for (unsigned int i = 0; i < settings->session.open_floating_windows.size(); i++) { FloatingWindow * floating_window = (FloatingWindow *) settings->session.open_floating_windows[i]; GdkRectangle rectangle = floating_window->rectangle_get(); GdkRegion *region = gdk_region_rectangle(&rectangle); gdk_region_subtract(available_region, region); gdk_region_destroy(region); } // Step 4: The rectangles that the area region consists of are requested, // and the biggest suitable rectangle is chosen for the window. // A rectangle is considered suitable if it has at least 10% of the width, and 10% of the height of the area rectangle. GdkRectangle *gdk_rectangles = NULL; gint rectangle_count = 0; gdk_region_get_rectangles(available_region, &gdk_rectangles, &rectangle_count); for (int i = 0; i < rectangle_count; ++i) { GdkRectangle & rectangle = gdk_rectangles[i]; if (rectangle.width >= (area_rectangle.width / 10)) { if (rectangle.height >= (area_rectangle.height / 10)) { if ((rectangle.width * rectangle.height) > (my_gdk_rectangle.width * my_gdk_rectangle.height)) { my_gdk_rectangle = rectangle; } } } } g_free(gdk_rectangles); // Step 5: The available region is destroyed. gdk_region_destroy(available_region); // Step 6: If no area big enough is found, then the window that takes most space in the area is chosen, // the longest side is halved, and the new window is put in that freed area. if ((my_gdk_rectangle.width == 0) || (my_gdk_rectangle.height == 0)) { FloatingWindow * resize_window_pointer = NULL; int largest_size = 0; for (unsigned int i = 0; i < settings->session.open_floating_windows.size(); i++) { FloatingWindow *floating_window = (FloatingWindow *) settings->session.open_floating_windows[i]; GdkRectangle rectangle = floating_window->rectangle_get (); int size = rectangle.width * rectangle.height; if (size > largest_size) { resize_window_pointer = floating_window; largest_size = size; } } if (resize_window_pointer) { GdkRectangle resize_window_rectangle = resize_window_pointer->rectangle_get(); my_gdk_rectangle = resize_window_pointer->rectangle_get(); if (resize_window_rectangle.width > resize_window_rectangle.height) { resize_window_rectangle.width /= 2; my_gdk_rectangle.width /= 2; my_gdk_rectangle.x += resize_window_rectangle.width; } else { resize_window_rectangle.height /= 2; my_gdk_rectangle.height /= 2; my_gdk_rectangle.y += resize_window_rectangle.height; } resize_window_pointer->rectangle_set (resize_window_rectangle); } } } // Add the window to the layout and set its position and size. gtk_layout_put (GTK_LAYOUT (layout), vbox_window, my_gdk_rectangle.x, my_gdk_rectangle.y); rectangle_set (my_gdk_rectangle); // Store a pointer to this window in the Session. settings->session.open_floating_windows.push_back(gpointer (this)); }
static void _gegueb_event_cb(GdkEvent *event, gpointer user_data) { Gegueb_Window *thiz = user_data; switch(event->type) { case GDK_EXPOSE: case GDK_DAMAGE: { GdkRectangle *rects; Eina_Rectangle *r; int nrects; int i; gdk_region_union(thiz->regions, event->expose.region); gdk_region_get_rectangles(event->expose.region, &rects, &nrects); for (i = 0; i < nrects; i++) { r = malloc(sizeof(Eina_Rectangle)); r->x = rects[i].x; r->y = rects[i].y; r->w = rects[i].width; r->h = rects[i].height; thiz->damages = eina_list_append(thiz->damages, r); } if (!event->expose.count) { _gegueb_window_draw(thiz); } } break; case GDK_CONFIGURE: gegueb_document_configure(thiz->doc, event->configure.width, event->configure.height); _gegueb_window_draw(thiz); break; case GDK_DELETE: egueb_dom_window_close_notify(thiz->ewin); break; case GDK_MOTION_NOTIFY: //egueb_dom_input_feed_mouse_move(thiz->input, event->motion.x, event->motion.y); break; case GDK_BUTTON_PRESS: //egueb_dom_input_feed_mouse_down(thiz->input, event->button.button); break; case GDK_BUTTON_RELEASE: //egueb_dom_input_feed_mouse_up(thiz->input, event->button.button); break; case GDK_KEY_PRESS: printf("ui key press\n"); break; case GDK_KEY_RELEASE: printf("ui key release\n"); break; case GDK_ENTER_NOTIFY: printf("ui enter\n"); break; case GDK_LEAVE_NOTIFY: printf("ui leave\n"); break; case GDK_FOCUS_CHANGE: printf("ui focus\n"); break; } }