ClearlooksStepper clearlooks_scrollbar_get_stepper (GtkWidget *widget, GdkRectangle *stepper) { ClearlooksStepper value = CL_STEPPER_UNKNOWN; GdkRectangle tmp; GdkRectangle check_rectangle; GtkOrientation orientation; if (!GE_IS_RANGE (widget)) return CL_STEPPER_UNKNOWN; check_rectangle.x = widget->allocation.x; check_rectangle.y = widget->allocation.y; check_rectangle.width = stepper->width; check_rectangle.height = stepper->height; orientation = GTK_RANGE (widget)->orientation; if (widget->allocation.x == -1 && widget->allocation.y == -1) return CL_STEPPER_UNKNOWN; if (gdk_rectangle_intersect (stepper, &check_rectangle, &tmp)) value = CL_STEPPER_A; if (value == CL_STEPPER_UNKNOWN) /* Haven't found a match */ { if (orientation == GTK_ORIENTATION_HORIZONTAL) check_rectangle.x = widget->allocation.x + stepper->width; else check_rectangle.y = widget->allocation.y + stepper->height; if (gdk_rectangle_intersect (stepper, &check_rectangle, &tmp)) value = CL_STEPPER_B; } if (value == CL_STEPPER_UNKNOWN) /* Still haven't found a match */ { if (orientation == GTK_ORIENTATION_HORIZONTAL) check_rectangle.x = widget->allocation.x + widget->allocation.width - (stepper->width * 2); else check_rectangle.y = widget->allocation.y + widget->allocation.height - (stepper->height * 2); if (gdk_rectangle_intersect (stepper, &check_rectangle, &tmp)) value = CL_STEPPER_C; } if (value == CL_STEPPER_UNKNOWN) /* STILL haven't found a match */ { if (orientation == GTK_ORIENTATION_HORIZONTAL) check_rectangle.x = widget->allocation.x + widget->allocation.width - stepper->width; else check_rectangle.y = widget->allocation.y + widget->allocation.height - stepper->height; if (gdk_rectangle_intersect (stepper, &check_rectangle, &tmp)) value = CL_STEPPER_D; } return value; }
static void img_cell_renderer_anim_render( GtkCellRenderer *cell, GdkDrawable *window, GtkWidget *widget, GdkRectangle *background_a, GdkRectangle *cell_a, GdkRectangle *expose_a, GtkCellRendererState state ) { ImgCellRendererAnimPrivate *priv; GdkPixbufAnimationIter *iter; GdkPixbuf *pixbuf; cairo_t *cr; GdkRectangle rect, draw_rect; priv = IMG_CELL_RENDERER_ANIM_GET_PRIVATE ( cell ); /* Get image size */ img_cell_renderer_anim_get_size( cell, widget, cell_a, &rect.x, &rect.y, &rect.width, &rect.height ); rect.x += cell_a->x + cell->xpad; rect.y += cell_a->y + cell->ypad; rect.width -= 2 * cell->xpad; rect.height -= 2 * cell->ypad; /* Check for overlaping */ if( ! gdk_rectangle_intersect( cell_a, &rect, &draw_rect ) || ! gdk_rectangle_intersect( expose_a, &draw_rect, &draw_rect ) ) return; /* Draw indicators */ cr = gdk_cairo_create( window ); /* Draw the current frame of the GdkPixbufAnimation */ iter = g_object_get_data( G_OBJECT( priv->anim ), "iter" ); if( ! iter ) { gint delay; /* Initialiize iter */ iter = gdk_pixbuf_animation_get_iter( priv->anim, NULL ); g_object_set_data_full( G_OBJECT( priv->anim ), "iter", iter, (GDestroyNotify)g_object_unref ); /* Install timeout */ delay = gdk_pixbuf_animation_iter_get_delay_time( iter ); gdk_threads_add_timeout( delay, (GSourceFunc)cb_timeout, iter ); } g_object_set_data( G_OBJECT( iter ), "widget", widget ); pixbuf = gdk_pixbuf_animation_iter_get_pixbuf( iter ); gdk_cairo_set_source_pixbuf( cr, pixbuf, rect.x, rect.y ); gdk_cairo_rectangle( cr, &draw_rect ); cairo_fill( cr ); cairo_destroy( cr ); }
void cb_view_vadjustment_value_changed(GtkAdjustment* GIRARA_UNUSED(adjustment), gpointer data) { zathura_t* zathura = data; if (zathura == NULL || zathura->document == NULL || zathura->ui.page_widget == NULL) { return; } GtkAdjustment* view_vadjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view)); GtkAdjustment* view_hadjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(zathura->ui.session->gtk.view)); GdkRectangle view_rect; /* get current adjustment values */ view_rect.y = 0; view_rect.height = gtk_adjustment_get_page_size(view_vadjustment); view_rect.x = 0; view_rect.width = gtk_adjustment_get_page_size(view_hadjustment); int page_padding = 1; girara_setting_get(zathura->ui.session, "page-padding", &page_padding); GdkRectangle center; center.x = (view_rect.width + 1) / 2; center.y = (view_rect.height + 1) / 2; center.height = center.width = (2 * page_padding) + 1; unsigned int number_of_pages = zathura_document_get_number_of_pages(zathura->document); double scale = zathura_document_get_scale(zathura->document); bool updated = false; /* find page that fits */ for (unsigned int page_id = 0; page_id < number_of_pages; page_id++) { zathura_page_t* page = zathura_document_get_page(zathura->document, page_id); GdkRectangle page_rect; GtkWidget* page_widget = zathura_page_get_widget(zathura, page); gtk_widget_translate_coordinates(page_widget, zathura->ui.session->gtk.view, 0, 0, &page_rect.x, &page_rect.y); page_rect.width = zathura_page_get_width(page) * scale; page_rect.height = zathura_page_get_height(page) * scale; if (gdk_rectangle_intersect(&view_rect, &page_rect, NULL) == TRUE) { zathura_page_set_visibility(page, true); if (zathura->global.update_page_number == true && updated == false && gdk_rectangle_intersect(¢er, &page_rect, NULL) == TRUE) { zathura_document_set_current_page_number(zathura->document, page_id); updated = true; } } else { zathura_page_set_visibility(page, false); } zathura_page_widget_update_view_time(ZATHURA_PAGE(page_widget)); } statusbar_page_number_update(zathura); }
static void sp_color_preview_paint (SPColorPreview *cp, GdkRectangle *area) { GtkWidget *widget; GdkRectangle warea, carea; GdkRectangle wpaint, cpaint; gint bx, by, w2; widget = GTK_WIDGET (cp); warea.x = widget->allocation.x; warea.y = widget->allocation.y; warea.width = widget->allocation.width; warea.height = widget->allocation.height; if (!gdk_rectangle_intersect (area, &warea, &wpaint)) return; /* Draw shadow */ gtk_draw_shadow (widget->style, widget->window, (GtkStateType)widget->state, GTK_SHADOW_ETCHED_IN, warea.x, warea.y, warea.width, warea.height); /* Transparent area */ bx = widget->style->xthickness; by = widget->style->ythickness; w2 = warea.width / 2; carea.x = warea.x + bx; carea.y = warea.y + by; carea.width = w2 - bx; carea.height = warea.height - 2 * by; if (gdk_rectangle_intersect (area, &carea, &cpaint)) { nr_gdk_draw_rgba32_solid (widget->window, widget->style->black_gc, cpaint.x, cpaint.y, cpaint.width, cpaint.height, cp->rgba); } /* Solid area */ carea.x = warea.x + w2; carea.y = warea.y + by; carea.width = warea.width - bx - w2; carea.height = warea.height - 2 * by; if (gdk_rectangle_intersect (area, &carea, &cpaint)) { nr_gdk_draw_rgba32_solid (widget->window, widget->style->black_gc, cpaint.x, cpaint.y, cpaint.width, cpaint.height, cp->rgba | 0xff); } }
static void xfce_cell_renderer_pixbuf_on_demand_render(GtkCellRenderer *cr, GdkWindow *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, GtkCellRendererState flags) { XfceCellRendererPixbufOnDemandPrivate *priv; GdkPixbuf *pix; GdkRectangle r; GdkRectangle draw_rect; GdkGC *gc; priv = XFCE_CELL_RENDERER_PIXBUF_ON_DEMAND (cr)->priv; if (!priv->loaded) xfce_cell_renderer_pixbuf_on_demand_load (XFCE_CELL_RENDERER_PIXBUF_ON_DEMAND (cr), GDK_INTERP_NEAREST); if (priv->pixbuf) pix = priv->pixbuf; else if (priv->fallback_pixbuf) pix = priv->fallback_pixbuf; else pix = NULL; /*priv->dummypix;*/ r.x = 0; r.y = 0; r.width = priv->width; r.height = priv->height; gc = gdk_gc_new (window); r.x = r.x + cell_area->x; r.y = r.y + cell_area->y; r.width = r.width - 0; /* # xpad * 2; */ r.height = r.height - 0; /* # ypad * 2; */ if (pix && gdk_rectangle_intersect(cell_area, &r, &draw_rect) && gdk_rectangle_intersect(expose_area, &draw_rect, &draw_rect)) gdk_draw_pixbuf (window, gc, pix, draw_rect.x - r.x, draw_rect.y - r.y, draw_rect.x, draw_rect.y, draw_rect.width, draw_rect.height, GDK_RGB_DITHER_NONE, 0, 0 ); g_object_unref (G_OBJECT (gc)); /* if (GTK_CELL_RENDERER (pb)->render) GTK_CELL_RENDERER (pb)->render (pb, window, widget, background_area, cell_area, expose_area, flags); */ }
/* * render a cell */ static void cell_renderer_break_icon_render(GtkCellRenderer *cell, GdkDrawable *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, GtkCellRendererState flags) { CellRendererBreakIcon *cellbreakpoint = (CellRendererBreakIcon*) cell; GdkPixbuf *pixbuf = NULL; GdkRectangle pix_rect; GdkRectangle draw_rect; cairo_t *cr; cell_renderer_break_icon_get_size (cell, widget, cell_area, &pix_rect.x, &pix_rect.y, &pix_rect.width, &pix_rect.height); pix_rect.x += cell_area->x + cell->xpad; pix_rect.y += cell_area->y + cell->ypad; pix_rect.width -= cell->xpad * 2; pix_rect.height -= cell->ypad * 2; if (!gdk_rectangle_intersect (cell_area, &pix_rect, &draw_rect) || !gdk_rectangle_intersect (expose_area, &draw_rect, &draw_rect)) return; if (cell->is_expander) { pixbuf = cellbreakpoint->pixbuf_file; } else if (!cellbreakpoint->enabled) { pixbuf = cellbreakpoint->pixbuf_disabled; } else if ((cellbreakpoint->condition && strlen(cellbreakpoint->condition)) || cellbreakpoint->hitscount) { pixbuf = cellbreakpoint->pixbuf_conditional; } else { pixbuf = cellbreakpoint->pixbuf_enabled; } if (!pixbuf) return; cr = gdk_cairo_create (window); gdk_cairo_set_source_pixbuf (cr, pixbuf, pix_rect.x, pix_rect.y); gdk_cairo_rectangle (cr, &draw_rect); cairo_fill (cr); cairo_destroy (cr); }
void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect) { if (!m_webView) return; GdkWindow* window = GTK_WIDGET(m_webView)->window; if (!window) return; GdkRectangle area = clipRect; GdkRectangle moveRect; GdkRectangle sourceRect = area; sourceRect.x -= delta.width(); sourceRect.y -= delta.height(); GdkRegion* invalidRegion = gdk_region_rectangle(&area); if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) { GdkRegion* moveRegion = gdk_region_rectangle(&moveRect); gdk_window_move_region(window, moveRegion, delta.width(), delta.height()); gdk_region_offset(moveRegion, delta.width(), delta.height()); gdk_region_subtract(invalidRegion, moveRegion); gdk_region_destroy(moveRegion); } gdk_window_invalidate_region(window, invalidRegion, FALSE); gdk_region_destroy(invalidRegion); }
/* Calculates the intersection of two rectangles. */ int clip_GDK_RECTANGLEINTERSECT(ClipMachine * ClipMachineMemory) { ClipVar *creg1 = _clip_spar(ClipMachineMemory, 1); ClipVar *creg2 = _clip_spar(ClipMachineMemory, 2); //ClipVar *cdest = _clip_spar(ClipMachineMemory,3); GdkRectangle reg1, reg2, dest; CHECKARG(1, MAP_type_of_ClipVarType); CHECKARG(2, MAP_type_of_ClipVarType); CHECKOPT(3, MAP_type_of_ClipVarType); _map_get_gdk_rectangle(ClipMachineMemory, creg1, ®1); _map_get_gdk_rectangle(ClipMachineMemory, creg2, ®2); _clip_retl(ClipMachineMemory, gdk_rectangle_intersect(®1, ®2, &dest)); if (_clip_parinfo(ClipMachineMemory, 3) == MAP_type_of_ClipVarType) _map_put_gdk_rectangle(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3), &dest); return 0; err: return 1; }
/* Kreslicí funkce spoleèná pro gtk_ev_draw() a gtk_ev_expose(), která kreslí * hlavní okno widgetu */ static void gtk_ev_paint(GtkEv *ev, GdkRectangle *area) { GtkWidget *widget; g_return_if_fail(ev); g_return_if_fail(area); widget = GTK_WIDGET(ev); if(!GTK_WIDGET_DRAWABLE(widget)) return; /* Not visible and mapped */ gdk_window_clear_area(widget->window, area->x, area->y, area->width, area->height); gdk_gc_set_clip_rectangle(widget->style->black_gc, area); /* Èerný rámeèek kolem vnitøního okna */ gdk_draw_rectangle(widget->window, widget->style->black_gc, FALSE, ev->ev_win_rect.x-1, ev->ev_win_rect.y-1, ev->ev_win_rect.width+2, ev->ev_win_rect.height+2); gdk_gc_set_clip_rectangle(widget->style->black_gc, NULL); /* Text (seznam zachycených událostí) */ if(ev->list) { GdkRectangle intersect; if(gdk_rectangle_intersect(&ev->list_rect, area, &intersect)) { static const gint space = 2; gint line, step, first_baseline; GList *p; GdkFont *font = gtk_style_get_font(widget->style); step = font->ascent + font->descent + space; first_baseline = ev->list_rect.y + font->ascent + space; line = 0; for(p = ev->list; p; p = g_list_next(p)) { gchar **pev = p->data; gint i; for(i = 0; pev[i]; i++) { gtk_paint_string(widget->style, widget->window, widget->state, &intersect, widget, (char *) "ev", ev->list_rect.x, first_baseline + line*step, pev[i]); line++; } if(first_baseline + line*step - 2*step > intersect.y + intersect.height) break; } } } /* Grafické zvýraznìní, kdy¾ má okno focus */ if(GTK_WIDGET_HAS_FOCUS(widget)) gtk_paint_focus(widget->style, widget->window, GTK_WIDGET_STATE(widget), area, widget, (char *) "ev", 0, 0, -1, -1); }
static VALUE rg_intersect(VALUE self, VALUE other) { GdkRectangle dest; gboolean ret = gdk_rectangle_intersect(_SELF(self), _SELF(other), &dest); return ret ? GDKRECTANGLE2RVAL(&dest) : Qnil; }
static gboolean thumbalbum_thumbnail_is_in_viewport (GimvThumbView *tv, GimvThumb *thumb) { ThumbViewData *tv_data; GList *node; gint index; gboolean success; GdkRectangle area, cell_area, intersect_area; g_return_val_if_fail (GIMV_IS_THUMB_VIEW (tv), FALSE); g_return_val_if_fail (GIMV_IS_THUMB (thumb), FALSE); tv_data = g_object_get_data (G_OBJECT (tv), THUMBALBUM_LABEL); g_return_val_if_fail (tv_data, FALSE); node = g_list_find (tv->thumblist, thumb); index = g_list_position (tv->thumblist, node); /* widget area */ gtkutil_get_widget_area (tv_data->album, &area); /* cell area */ success = gimv_zlist_get_cell_area (GIMV_ZLIST (tv_data->album), index, &cell_area); g_return_val_if_fail (success, FALSE); /* intersect? */ if (gdk_rectangle_intersect (&area, &cell_area, &intersect_area)) return TRUE; else return FALSE; }
Rectangle * gtk_xournal_get_visible_area(GtkWidget * widget, PageView * p) { g_return_val_if_fail(widget != NULL, NULL); g_return_val_if_fail(GTK_IS_XOURNAL(widget), NULL); GtkXournal * xournal = GTK_XOURNAL(widget); GtkAllocation allocation = { 0 }; gtk_widget_get_allocation(widget, &allocation); int viewHeight = allocation.height; int viewWidth = allocation.width; GdkRectangle r1; GdkRectangle r2; GdkRectangle r3 = { 0, 0, 0, 0 }; r1.x = p->getX(); r1.y = p->getY(); r1.width = p->getDisplayWidth(); r1.height = p->getDisplayHeight(); r2.x = xournal->x; r2.y = xournal->y; r2.width = viewWidth; r2.height = viewHeight; gdk_rectangle_intersect(&r1, &r2, &r3); if (r3.width == 0 && r3.height == 0) { return NULL; } double zoom = xournal->view->getZoom(); return new Rectangle(MAX(r3.x, 0) / zoom, MAX(r3.y, 0) / zoom, r3.width / zoom, r3.height / zoom); }
static gboolean gtk_mng_view_expose (GtkWidget * widget, GdkEventExpose * event) { FUNCTION_ENTRY(); g_return_val_if_fail (IS_GTK_MNG_VIEW (widget), FALSE); g_return_val_if_fail (event != NULL, FALSE); if (GTK_WIDGET_REALIZED (widget)) { GdkRectangle dummy; GdkRectangle rectangle; GtkMngView * mng_view; mng_view = GTK_MNG_VIEW (widget); dummy.x = dummy.y = 0; dummy.width = mng_view->width; dummy.height = mng_view->height; if (gdk_rectangle_intersect (&dummy, &event->area, &rectangle)) gtk_mng_view_paint (mng_view, &rectangle); mng_display_resume(mng_view->MNG_handle); } FUNCTION_EXIT(); return FALSE; }
static VALUE rg_intersect(VALUE self, VALUE other) { GtkAllocation dest; gboolean ret = gdk_rectangle_intersect(_SELF(self), _SELF(other), &dest); return ret ? GTKALLOCATION2RVAL(&dest) : Qnil; }
static void gdl_dock_tablabel_paint (GtkWidget *widget, GdkEventExpose *event) { GdkRectangle dest, rect; GtkBin *bin; GdlDockTablabel *tablabel; gint border_width; bin = GTK_BIN (widget); tablabel = GDL_DOCK_TABLABEL (widget); border_width = GTK_CONTAINER (widget)->border_width; rect.x = widget->allocation.x + border_width; rect.y = widget->allocation.y + border_width; rect.width = tablabel->drag_handle_size * HANDLE_RATIO; rect.height = widget->allocation.height - 2*border_width; if (gdk_rectangle_intersect (&event->area, &rect, &dest)) { gtk_paint_handle (widget->style, widget->window, tablabel->active ? GTK_STATE_NORMAL : GTK_STATE_ACTIVE, GTK_SHADOW_NONE, &dest, widget, "dock-tablabel", rect.x, rect.y, rect.width, rect.height, GTK_ORIENTATION_VERTICAL); }; }
static void blank_region_in_pixbuf (GdkPixbuf *pixbuf, cairo_region_t *region) { int n_rects; int i; int width, height; cairo_rectangle_int_t pixbuf_rect; n_rects = cairo_region_num_rectangles (region); width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); pixbuf_rect.x = 0; pixbuf_rect.y = 0; pixbuf_rect.width = width; pixbuf_rect.height = height; for (i = 0; i < n_rects; i++) { cairo_rectangle_int_t rect, dest; cairo_region_get_rectangle (region, i, &rect); if (gdk_rectangle_intersect (&rect, &pixbuf_rect, &dest)) blank_rectangle_in_pixbuf (pixbuf, &dest); } }
static void dlarea_level_button_clicked(GtkWidget *widget, gpointer data) { log_debug("dlarea_level_button_clicked"); char *levels_mark = (char *)data; int levels = levels_mark[0] - '0'; if (! dl_area_choosed || ! AREA_BIG_ENOUGH()) { warn_dialog("Download area is not specified!"); return; } log_debug("guess network connecting..."); if (! guess_network_is_connecting(TRUE)) { if (! confirm_dialog("Seems no network connection,\ncontinue?")) return; } GdkRectangle rect; if (! gdk_rectangle_intersect(&dlarea, &g_view.fglayer.visible, &rect)) { warn_dialog("The selected area contains no map tiles."); return; } map_repo_t *repo = g_view.fglayer.repo; int zoom = repo->zoom; point_t tl = {rect.x + g_view.fglayer.tl_pixel.x, rect.y + g_view.fglayer.tl_pixel.y}; point_t br = {tl.x + rect.width, tl.y + rect.height}; coord_t tl_wgs84 = tilepixel_to_wgs84(tl, zoom, repo); coord_t br_wgs84 = tilepixel_to_wgs84(br, zoom, repo); /* try download... */ tile_batch_download(levels, tl_wgs84, br_wgs84); }
/** * gdk_screen_get_monitor_at_window: * @screen: a #GdkScreen. * @window: a #GdkWindow * @returns: the monitor number in which most of @window is located, * or if @window does not intersect any monitors, a monitor, * close to @window. * * Returns the number of the monitor in which the largest area of the * bounding rectangle of @window resides. * * Since: 2.2 **/ gint gdk_screen_get_monitor_at_window (GdkScreen *screen, GdkWindow *window) { gint num_monitors, i, area = 0, screen_num = -1; GdkRectangle win_rect; g_return_val_if_fail (GDK_IS_SCREEN (screen), -1); gdk_window_get_geometry (window, &win_rect.x, &win_rect.y, &win_rect.width, &win_rect.height, NULL); gdk_window_get_origin (window, &win_rect.x, &win_rect.y); num_monitors = gdk_screen_get_n_monitors (screen); for (i=0;i<num_monitors;i++) { GdkRectangle tmp_monitor, intersect; gdk_screen_get_monitor_geometry (screen, i, &tmp_monitor); gdk_rectangle_intersect (&win_rect, &tmp_monitor, &intersect); if (intersect.width * intersect.height > area) { area = intersect.width * intersect.height; screen_num = i; } } if (screen_num >= 0) return screen_num; else return get_nearest_monitor (screen, win_rect.x + win_rect.width / 2, win_rect.y + win_rect.height / 2); }
static void gimv_zalbum_prepare_cell (GimvZAlbum *album, GimvZAlbumCell *cell, GdkRectangle *cell_area, GdkRectangle *area) { GtkWidget *widget; GdkRectangle intersect_area; widget = GTK_WIDGET(album); if (gdk_rectangle_intersect (area, cell_area, &intersect_area)) gdk_draw_rectangle (widget->window, widget->style->bg_gc[CELL_STATE(cell)], TRUE, intersect_area.x, intersect_area.y, intersect_area.width, intersect_area.height); gtk_paint_shadow (widget->style, widget->window, CELL_STATE(cell), GTK_SHADOW_OUT, NULL, NULL, NULL, cell_area->x, cell_area->y, cell_area->width, cell_area->height); cell_area->x += CELL_PADDING; cell_area->y += CELL_PADDING; cell_area->width -= CELL_PADDING * 2; cell_area->height -= CELL_PADDING * 2; }
static void draw_eye (EyesApplet *eyes_applet, gint eye_num, gint pupil_x, gint pupil_y) { GdkPixbuf *pixbuf; GdkRectangle rect, r1, r2; pixbuf = gdk_pixbuf_copy (eyes_applet->eye_image); r1.x = pupil_x - eyes_applet->pupil_width / 2; r1.y = pupil_y - eyes_applet->pupil_height / 2; r1.width = eyes_applet->pupil_width; r1.height = eyes_applet->pupil_height; r2.x = 0; r2.y = 0; r2.width = eyes_applet->eye_width; r2.height = eyes_applet->eye_height; gdk_rectangle_intersect (&r1, &r2, &rect); gdk_pixbuf_composite (eyes_applet->pupil_image, pixbuf, rect.x, rect.y, rect.width, rect.height, pupil_x - eyes_applet->pupil_width / 2, pupil_y - eyes_applet->pupil_height / 2, 1.0, 1.0, GDK_INTERP_BILINEAR, 255); gtk_image_set_from_pixbuf (GTK_IMAGE (eyes_applet->eyes[eye_num]), pixbuf); g_object_unref (pixbuf); }
//borrowed from gtk static gint get_monitor_at_window(MetaWindow* window) { gint num_monitors, i, area = 0, screen_num = -1; GdkRectangle win_rect; GdkScreen* screen = gdk_screen_get_default(); meta_window_get_outer_rect(window, (MetaRectangle*)&win_rect); num_monitors = gdk_screen_get_n_monitors (screen); for (i=0; i<num_monitors; i++) { GdkRectangle tmp_monitor, intersect; gdk_screen_get_monitor_geometry (screen, i, &tmp_monitor); gdk_rectangle_intersect (&win_rect, &tmp_monitor, &intersect); if (intersect.width * intersect.height > area) { area = intersect.width * intersect.height; screen_num = i; } } if (screen_num >= 0) return screen_num; else return get_nearest_monitor (screen, win_rect.x + win_rect.width / 2, win_rect.y + win_rect.height / 2); }
void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect) { GdkWindow* window = GTK_WIDGET(m_webView)->window; if (!window) return; // We cannot use gdk_window_scroll here because it is only able to // scroll the whole window at once, and we often need to scroll // portions of the window only (think frames). GdkRectangle area = clipRect; GdkRectangle moveRect; GdkRectangle sourceRect = area; sourceRect.x -= delta.width(); sourceRect.y -= delta.height(); GdkRegion* invalidRegion = gdk_region_rectangle(&area); if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) { GdkRegion* moveRegion = gdk_region_rectangle(&moveRect); gdk_window_move_region(window, moveRegion, delta.width(), delta.height()); gdk_region_offset(moveRegion, delta.width(), delta.height()); gdk_region_subtract(invalidRegion, moveRegion); gdk_region_destroy(moveRegion); } gdk_window_invalidate_region(window, invalidRegion, FALSE); gdk_region_destroy(invalidRegion); }
static inline void wx_gdk_screen_get_monitor_workarea(GdkScreen* screen, int monitor, GdkRectangle* dest) { #if GTK_CHECK_VERSION(3,4,0) if (gtk_check_version(3,4,0) == NULL) gdk_screen_get_monitor_workarea(screen, monitor, dest); else #endif { gdk_screen_get_monitor_geometry(screen, monitor, dest); #ifdef GDK_WINDOWING_X11 #ifdef __WXGTK3__ if (GDK_IS_X11_SCREEN(screen)) #endif { GdkRectangle rect = { 0 }; wxGetWorkAreaX11(GDK_SCREEN_XSCREEN(screen), rect.x, rect.y, rect.width, rect.height); // in case _NET_WORKAREA result is too large if (rect.width && rect.height) gdk_rectangle_intersect(dest, &rect, dest); } #endif // GDK_WINDOWING_X11 } }
static void gdk_window_compute_parent_pos (GdkWindowImplWin32 *window, GdkWindowParentPos *parent_pos) { GdkWindowObject *wrapper; GdkWindowObject *parent; GdkRectangle tmp_clip; int clip_xoffset = 0; int clip_yoffset = 0; g_return_if_fail (GDK_IS_WINDOW_IMPL_WIN32 (window)); wrapper = GDK_WINDOW_OBJECT (GDK_DRAWABLE_IMPL_WIN32 (window)->wrapper); parent_pos->x = 0; parent_pos->y = 0; parent_pos->win32_x = 0; parent_pos->win32_y = 0; /* We take a simple approach here and simply consider toplevel * windows not to clip their children on the right/bottom, since the * size of toplevel windows is not directly under our * control. Clipping only really matters when scrolling and * generally we aren't going to be moving the immediate child of a * toplevel beyond the bounds of that toplevel. * * We could go ahead and recompute the clips of toplevel windows and * their descendents when we receive size notification, but it would * probably not be an improvement in most cases. */ parent_pos->clip_rect.x = 0; parent_pos->clip_rect.y = 0; parent_pos->clip_rect.width = G_MAXINT; parent_pos->clip_rect.height = G_MAXINT; parent = (GdkWindowObject *)wrapper->parent; while (parent && parent->window_type == GDK_WINDOW_CHILD) { GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (parent->impl); tmp_clip.x = - clip_xoffset; tmp_clip.y = - clip_yoffset; tmp_clip.width = impl->width; tmp_clip.height = impl->height; gdk_rectangle_intersect (&parent_pos->clip_rect, &tmp_clip, &parent_pos->clip_rect); parent_pos->x += parent->x; parent_pos->y += parent->y; parent_pos->win32_x += impl->position_info.x; parent_pos->win32_y += impl->position_info.y; clip_xoffset += parent->x; clip_yoffset += parent->y; parent = (GdkWindowObject *)parent->parent; } }
/* * render a cell */ static void cell_renderer_frame_icon_render(GtkCellRenderer *cell, GdkDrawable *window, GtkWidget *widget, GdkRectangle *background_area, GdkRectangle *cell_area, GdkRectangle *expose_area, GtkCellRendererState flags) { CellRendererFrameIcon *cellframe = (CellRendererFrameIcon*) cell; GdkPixbuf *pixbuf = NULL; GdkRectangle pix_rect; GdkRectangle draw_rect; cairo_t *cr; cell_renderer_frame_icon_get_size (cell, widget, cell_area, &pix_rect.x, &pix_rect.y, &pix_rect.width, &pix_rect.height); pix_rect.x += cell_area->x + cell->xpad; pix_rect.y += cell_area->y + cell->ypad; pix_rect.width -= cell->xpad * 2; pix_rect.height -= cell->ypad * 2; if (!gdk_rectangle_intersect (cell_area, &pix_rect, &draw_rect) || !gdk_rectangle_intersect (expose_area, &draw_rect, &draw_rect)) return; if (cellframe->active_frame) { pixbuf = cellframe->pixbuf_active; } else if (flags & GTK_CELL_RENDERER_PRELIT) { pixbuf = cellframe->pixbuf_highlighted; } if (!pixbuf) return; cr = gdk_cairo_create (window); gdk_cairo_set_source_pixbuf (cr, pixbuf, pix_rect.x, pix_rect.y); gdk_cairo_rectangle (cr, &draw_rect); cairo_fill (cr); cairo_destroy (cr); }
void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect) { GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(m_webView)); if (!window) return; m_pendingScrollInvalidations = true; // We cannot use gdk_window_scroll here because it is only able to // scroll the whole window at once, and we often need to scroll // portions of the window only (think frames). GdkRectangle area = clipRect; GdkRectangle moveRect; GdkRectangle sourceRect = area; sourceRect.x -= delta.width(); sourceRect.y -= delta.height(); #ifdef GTK_API_VERSION_2 GdkRegion* invalidRegion = gdk_region_rectangle(&area); if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) { GdkRegion* moveRegion = gdk_region_rectangle(&moveRect); gdk_window_move_region(window, moveRegion, delta.width(), delta.height()); gdk_region_offset(moveRegion, delta.width(), delta.height()); gdk_region_subtract(invalidRegion, moveRegion); gdk_region_destroy(moveRegion); } gdk_window_invalidate_region(window, invalidRegion, FALSE); gdk_region_destroy(invalidRegion); #else cairo_region_t* invalidRegion = cairo_region_create_rectangle(&area); if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) { cairo_region_t* moveRegion = cairo_region_create_rectangle(&moveRect); gdk_window_move_region(window, moveRegion, delta.width(), delta.height()); cairo_region_translate(moveRegion, delta.width(), delta.height()); cairo_region_subtract(invalidRegion, moveRegion); cairo_region_destroy(moveRegion); } gdk_window_invalidate_region(window, invalidRegion, FALSE); cairo_region_destroy(invalidRegion); #endif }
void capture(GtkWidget *button, gpointer ip) { int cmd, sec; char *file = NULL; char message[1024]; time_t tt; struct tm *tm_ptr = NULL; struct sockaddr_in addr; gint x, y; GdkScreen* cur_screen = NULL; GdkWindow* window = NULL; GdkPixbuf* pixbuf_screenshot = NULL; GdkRectangle rect; GdkRectangle screen_rect; LinpopChat chat; gboolean result; file = (char *)g_malloc(32); inet_aton(ip,&addr.sin_addr); result = getChatByIP(addr,&chat); assert(result == TRUE); time(&tt); tm_ptr = localtime(&tt); strftime(file, 32, "%Y%m%d%H%M%S", tm_ptr); strcat(file, ".jpg"); g_printf("ready to capture.....\r\n"); if (cur_screen == NULL) cur_screen = gdk_screen_get_default (); screen_rect.x = 0; screen_rect.y = 0; screen_rect.width = gdk_screen_get_width (cur_screen); //get screen width screen_rect.height = gdk_screen_get_height (cur_screen); //get screen height g_print("screen_rect: x=%d,y=%d,w=%d,h=%d\n",screen_rect.x,screen_rect.y,screen_rect.width,screen_rect.height); window = gdk_screen_get_root_window (cur_screen); //get window by screen //Window xwin = GDK_WINDOW_XID(window); //get window id //g_print("xwindow id is %x\n",xwin); gdk_window_get_origin (window, &x, &y); //get origin point rect.x = x; rect.y = y; gdk_drawable_get_size (GDK_DRAWABLE (window), &rect.width,&rect.height); //get drawable size g_print("rect: x=%d,y=%d,w=%d,h=%d\n",rect.x,rect.y,rect.width,rect.height); if (! gdk_rectangle_intersect (&rect, &screen_rect, &rect)) { //obtain the intersect area from rect and screen_rect g_print("Capture failed!...\r\n"); printInfoToTextView(chat.showTextView,option.user,"Capture failed!..\n"); return; } g_print("capture rect: x=%d,y=%d,w=%d,h=%d\n",rect.x,rect.y,rect.width,rect.height); pixbuf_screenshot = gdk_pixbuf_get_from_drawable (NULL, window, NULL,rect.x - x, rect.y - y, 0, 0, rect.width, rect.height); //get pixbuf from drawable widget gdk_pixbuf_save (pixbuf_screenshot, file, "jpeg", NULL, "quality","100", NULL); //save pixbuf to jpeg format file g_object_unref (pixbuf_screenshot); //free pixbuf g_print("Capture saved!!!\r\n"); sprintf(message,"%s %s",file,"saved in current director."); printInfoToTextView(chat.showTextView,option.user,message); }
/** * uni_image_view_repaint_area: * @paint_rect: The rectangle on the widget that needs to be redrawn. * * Redraws the porition of the widget defined by @paint_rect. **/ static int uni_image_view_repaint_area (UniImageView * view, GdkRectangle * paint_rect) { if (view->is_rendering) return FALSE; // Do not draw zero size rectangles. if (!paint_rect->width || !paint_rect->height) return FALSE; view->is_rendering = TRUE; // Image area is the area on the widget occupied by the pixbuf. GdkRectangle image_area; Size alloc = uni_image_view_get_allocated_size (view); uni_image_view_get_draw_rect (view, &image_area); if (image_area.x > 0 || image_area.y > 0 || image_area.width < alloc.width || image_area.height < alloc.height) { uni_image_view_draw_background (view, &image_area, alloc); } GtkWidget *widget = GTK_WIDGET (view); // Paint area is the area on the widget that should be redrawn. GdkRectangle paint_area; gboolean intersects = gdk_rectangle_intersect (&image_area, paint_rect, &paint_area); if (intersects && view->pixbuf) { int src_x = (int) ((view->offset_x + (gdouble) paint_area.x - (gdouble) image_area.x) + 0.5); int src_y = (int) ((view->offset_y + (gdouble) paint_area.y - (gdouble) image_area.y) + 0.5); UniPixbufDrawOpts opts = { view->zoom, (GdkRectangle) { src_x, src_y, paint_area.width, paint_area.height }, paint_area.x, paint_area.y, view->interp, view->pixbuf }; uni_dragger_paint_image (UNI_DRAGGER(view->tool), &opts, widget->window); } view->is_rendering = FALSE; return TRUE; }
gboolean gimp_overlay_child_expose (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 == gtk_widget_get_window (widget)) { GtkAllocation child_allocation; GdkRectangle bounds; gtk_widget_get_allocation (child->widget, &child_allocation); gimp_overlay_child_transform_bounds (child, &child_allocation, &bounds); if (gtk_widget_get_visible (child->widget) && gdk_rectangle_intersect (&event->area, &bounds, NULL)) { GdkPixmap *pixmap = gdk_offscreen_window_get_pixmap (child->window); cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (widget)); gdk_cairo_region (cr, event->region); cairo_clip (cr); cairo_transform (cr, &child->matrix); gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0); cairo_paint_with_alpha (cr, child->opacity); cairo_destroy (cr); } } else if (event->window == child->window) { if (! gtk_widget_get_app_paintable (child->widget)) gtk_paint_flat_box (gtk_widget_get_style (child->widget), event->window, GTK_STATE_NORMAL, GTK_SHADOW_NONE, &event->area, widget, NULL, 0, 0, -1, -1); gtk_container_propagate_expose (GTK_CONTAINER (widget), child->widget, event); return TRUE; } return FALSE; }
static gboolean clamp_to_window (cairo_rectangle_int_t *out, GdkWindow *window, cairo_rectangle_int_t *in) { cairo_rectangle_int_t window_area = { 0, }; window_area.width = gdk_window_get_width (window); window_area.height = gdk_window_get_height (window); return gdk_rectangle_intersect ((GdkRectangle *) in, (GdkRectangle *) &window_area, (GdkRectangle *) in); }