static void maybe_update_shape (GtkTooltip *tooltip) { cairo_t *cr; cairo_surface_t *surface; cairo_region_t *region; /* fallback to XShape only for non-composited clients */ if (gtk_widget_is_composited (tooltip->window)) { gtk_widget_shape_combine_region (tooltip->window, NULL); return; } surface = gdk_window_create_similar_surface (gtk_widget_get_window (tooltip->window), CAIRO_CONTENT_COLOR_ALPHA, gtk_widget_get_allocated_width (tooltip->window), gtk_widget_get_allocated_height (tooltip->window)); cr = cairo_create (surface); paint_background_and_frame (tooltip, cr); cairo_destroy (cr); region = gdk_cairo_region_create_from_surface (surface); gtk_widget_shape_combine_region (tooltip->window, region); cairo_surface_destroy (surface); cairo_region_destroy (region); }
static gboolean draw_cb (GtkWidget *widget, cairo_t *cr) { gint width, height; width = gtk_widget_get_allocated_width (widget); height = gtk_widget_get_allocated_height (widget); cairo_rectangle (cr, 0, 0, width, height); cairo_set_source_rgb (cr, 0, 0, 0); cairo_fill (cr); draw_horizontal_scrollbar (widget, cr, 10, 10, width - 20, 10, 30, GTK_STATE_FLAG_NORMAL); draw_horizontal_scrollbar (widget, cr, 10, 30, width - 20, 10, 40, GTK_STATE_FLAG_PRELIGHT); draw_horizontal_scrollbar (widget, cr, 10, 50, width - 20, 10, 50, GTK_STATE_FLAG_ACTIVE|GTK_STATE_FLAG_PRELIGHT); draw_text (widget, cr, 10, 70, width - 20, 20, "Not selected", GTK_STATE_FLAG_NORMAL); draw_text (widget, cr, 10, 100, width - 20, 20, "Selected", GTK_STATE_FLAG_SELECTED); draw_check (widget, cr, 10, 130, GTK_STATE_FLAG_NORMAL); draw_check (widget, cr, 40, 130, GTK_STATE_FLAG_CHECKED); draw_radio (widget, cr, 70, 130, GTK_STATE_FLAG_NORMAL); draw_radio (widget, cr, 100, 130, GTK_STATE_FLAG_CHECKED); return FALSE; }
void qp_graph_grid_draw(struct qp_graph *gr, struct qp_plot *p, cairo_t *cr, int width, int height) { int64_t xmin_mat, xmax_mat, xinc, ymin_mat, ymax_mat, yinc; double xpow_part, ypow_part; PangoLayout *pangolayout = NULL; int view_width, view_height; ASSERT(gr); ASSERT(p); ASSERT(gr->drawing_area); ASSERT(gr->qp); ASSERT(gr->qp->window); if(!gr->show_grid) return; PreDrawGrid(gr, p, &xmin_mat, &xmax_mat, &xinc, &xpow_part, &ymin_mat, &ymax_mat, &yinc, &ypow_part, width, height); view_width = gtk_widget_get_allocated_width(gr->drawing_area); view_height = gtk_widget_get_allocated_height(gr->drawing_area); if(gr->grid_numbers) pangolayout = get_pangolayout(gr, cr); #if 0 DEBUG("\nxmin=%g xmax=%g\n", qp_plot_get_xval(p, 0), qp_plot_get_xval(p, width)); APPEND("ymin=%g ymax=%g\n", qp_plot_get_yval(p, height), qp_plot_get_yval(p, 0)); APPEND("xmin_mat=%ld xmax_mat=%ld xinc=%ld xpow_part=%g \n", xmin_mat, xmax_mat, xinc, xpow_part); APPEND("ymin_mat=%ld ymax_mat=%ld yinc=%ld ypow_part=%g \n", ymin_mat, ymax_mat, yinc, ypow_part); APPEND("delta_x pixels between lines=%d\n", qp_plot_get_xpixel(p, xpow_part*(xmin_mat + xinc)) - qp_plot_get_xpixel(p, xpow_part*(xmin_mat))); APPEND("delta_y pixels between lines=%d\n", qp_plot_get_ypixel(p, ypow_part*ymin_mat) - qp_plot_get_ypixel(p, ypow_part*(ymin_mat + yinc))); #endif if(gr->same_x_scale) DrawXGrid(cr, pangolayout, gr, p, xmin_mat, xmax_mat, xinc, xpow_part, ymin_mat, ymax_mat, yinc, ypow_part, width, height, view_height); if(gr->same_y_scale) DrawYGrid(cr, pangolayout, gr, p, xmin_mat, xmax_mat, xinc, xpow_part, ymin_mat, ymax_mat, yinc, ypow_part, width, height, view_width); }
static gboolean set_paned_position (GtkWidget *paned) { gtk_paned_set_position (GTK_PANED (paned), gtk_widget_get_allocated_height (paned) / 2); g_object_unref (paned); return FALSE; }
static void my_intensity_box_realize (GtkWidget * widget) { MyIntensityBox *self = MY_INTENSITY_BOX (widget); MyIntensityBoxPrivate *priv; priv = my_intensity_box_get_instance_private (self); GTK_WIDGET_CLASS(my_intensity_box_parent_class)->realize(widget); gint width, height; GtkWidget *label = gtk_label_new ("test"); GdkRectangle rect; width = gtk_widget_get_allocated_width (widget); height = gtk_widget_get_allocated_height (widget); rect.x = 0; rect.y = height - (priv->y / (priv->y_max - priv->y_min)) * height; rect.height = 0; rect.width = width; /*priv->popover = gtk_popover_new (GTK_WIDGET (self));*/ /*gtk_popover_set_modal (GTK_POPOVER (priv->popover), FALSE);*/ /*gtk_popover_set_pointing_to (GTK_POPOVER (priv->popover), &rect);*/ /*gtk_popover_set_position (GTK_POPOVER (priv->popover), GTK_POS_TOP);*/ /*gtk_container_add (GTK_CONTAINER (priv->popover), label);*/ /*gtk_container_set_border_width (GTK_CONTAINER (priv->popover), 6);*/ /*gtk_widget_show (label);*/ /*gtk_widget_set_visible (GTK_WIDGET (priv->popover), TRUE);*/ }
static void maybe_update_shape (GtkWidget *widget) { cairo_t *cr; cairo_surface_t *surface; cairo_region_t *region; /* fallback to XShape only for non-composited clients */ if (gtk_widget_is_composited (widget)) { gtk_widget_shape_combine_region (widget, NULL); return; } surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR_ALPHA, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); cr = cairo_create (surface); label_draw_background_and_frame (widget, cr, TRUE); cairo_destroy (cr); region = gdk_cairo_region_create_from_surface (surface); gtk_widget_shape_combine_region (widget, region); cairo_surface_destroy (surface); cairo_region_destroy (region); }
static gboolean handle_draw_cb (GtkWidget * widget, cairo_t * cr, gpointer user_data) { GstVideoRectangle *r = &anim_state.rect; GtkStyle *style; int width, height; width = gtk_widget_get_allocated_width (widget); height = gtk_widget_get_allocated_height (widget); style = gtk_widget_get_style (widget); gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_NORMAL]); /* we should only redraw outside of the video rect! */ cairo_rectangle (cr, 0, 0, r->x, height); cairo_rectangle (cr, r->x + r->w, 0, width - (r->x + r->w), height); cairo_rectangle (cr, 0, 0, width, r->y); cairo_rectangle (cr, 0, r->y + r->h, width, height - (r->y + r->h)); cairo_fill (cr); if (verbose) { g_print ("draw(%p)\n", widget); } gst_x_overlay_expose (anim_state.overlay); return FALSE; }
static gboolean gtk_files_draw (GtkWidget *files, cairo_t *cr) { cairo_text_extents_t extents; gint width = gtk_widget_get_allocated_width (files); gint height = gtk_widget_get_allocated_height (files); cairo_set_font_size (cr, 20); cairo_set_source_rgb (cr, 0, 0, 0); cairo_rectangle(cr, 0, 0, width, height); cairo_fill (cr); cairo_set_source_rgb (cr, .8, .4, .4); cairo_rectangle (cr, 0, 0, width, 50); cairo_fill (cr); cairo_set_source_rgb (cr, .8, .6, .8); cairo_rectangle (cr, 0, 60, width, 25); cairo_fill (cr); cairo_set_source_rgb (cr, .6, .6, .8); cairo_rectangle (cr, 0, 95, width, height - 25 - ((215 + 25) * (NUM_PANES - 1))); cairo_rectangle (cr, 0, height - 100, width, 100); cairo_fill (cr); // black indent cairo_set_source_rgb (cr, 0, 0, 0); cairo_rectangle(cr, 0, 25, 25, height - 50); cairo_arc (cr, 0, 25, 25, 0, 2 * M_PI); // TODO cairo_arc (cr, 0, height - 25, 25, 0, 2 * M_PI); // TODO cairo_fill (cr); return TRUE; }
static gboolean get_child_position (GtkOverlay *overlay, GtkWidget *widget, GtkAllocation *alloc, GtkWidget *relative) { GtkRequisition req; GtkWidget *child; GtkAllocation main_alloc; gint x, y; child = gtk_bin_get_child (GTK_BIN (overlay)); gtk_widget_translate_coordinates (relative, child, 0, 0, &x, &y); main_alloc.x = x; main_alloc.y = y; main_alloc.width = gtk_widget_get_allocated_width (relative); main_alloc.height = gtk_widget_get_allocated_height (relative); gtk_widget_get_preferred_size (widget, NULL, &req); alloc->x = main_alloc.x; alloc->width = MIN (main_alloc.width, req.width); if (gtk_widget_get_halign (widget) == GTK_ALIGN_END) alloc->x += main_alloc.width - req.width; alloc->y = main_alloc.y; alloc->height = MIN (main_alloc.height, req.height); if (gtk_widget_get_valign (widget) == GTK_ALIGN_END) alloc->y += main_alloc.height - req.height; return TRUE; }
static gboolean render_cb(GtkGLArea* area, GdkGLContext* ctxt, gpointer udata) { GtPlayerMpv* self = GT_PLAYER_MPV(udata); GtPlayerMpvPrivate* priv = gt_player_mpv_get_instance_private(self); int width; int height; int fbo; if (!priv->opengl_ready) { check_mpv_error(mpv_opengl_cb_init_gl(priv->mpv_opengl, NULL, get_proc_address, NULL)); priv->opengl_ready = TRUE; } width = gtk_widget_get_allocated_height(priv->opengl_area); height = (-1)*gtk_widget_get_allocated_width(priv->opengl_area); fbo = -1; glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo); mpv_opengl_cb_draw(priv->mpv_opengl, fbo, width, height); return TRUE; }
static gboolean window_menu_on_expose(GtkWidget* widget, GdkEventExpose* event, gpointer data) #endif { WindowMenu* window_menu = data; if (gtk_widget_has_focus(window_menu->applet)) gtk_paint_focus(gtk_widget_get_style(widget), #if GTK_CHECK_VERSION (3, 0, 0) cr, #else gtk_widget_get_window(widget), #endif gtk_widget_get_state(widget), #if !GTK_CHECK_VERSION (3, 0, 0) NULL, #endif widget, "menu-applet", 0, 0, #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); #else -1, -1); #endif return FALSE; }
/************************************************************************** Put the popup on a smart position, after the real size of the widget is known: left of the cursor if within the right half of the map, and vice versa; displace the popup so as not to obscure it by the mouse cursor; stay always within the map if possible. **************************************************************************/ static void popupinfo_positioning_callback(GtkWidget *w, GtkAllocation *alloc, gpointer data) { struct tmousepos *mousepos = data; gint x, y; struct tile *ptile; ptile = canvas_pos_to_tile(mousepos->x, mousepos->y); if (tile_to_canvas_pos(&x, &y, ptile)) { gint minx, miny, maxy; gdk_window_get_origin(gtk_widget_get_window(map_canvas), &minx, &miny); maxy = miny + gtk_widget_get_allocated_height(map_canvas); if (x > mapview.width/2) { /* right part of the map */ x += minx; y += miny + (tileset_tile_height(tileset) - alloc->height)/2; y = CLIP(miny, y, maxy - alloc->height); gtk_window_move(GTK_WINDOW(w), x - alloc->width, y); } else { /* left part of the map */ x += minx + tileset_tile_width(tileset); y += miny + (tileset_tile_height(tileset) - alloc->height)/2; y = CLIP(miny, y, maxy - alloc->height); gtk_window_move(GTK_WINDOW(w), x, y); } } }
static gboolean vid_area_render_handler( GtkGLArea *area, GdkGLContext *context, gpointer data ) { gmpv_handle *ctx = data; int width; int height; int fbo; if(!ctx->opengl_ready) { mpv_check_error(mpv_opengl_cb_init_gl( ctx->opengl_ctx, NULL, get_proc_address, NULL )); ctx->opengl_ready = TRUE; } width = gtk_widget_get_allocated_width(GTK_WIDGET(area)); height = (-1)*gtk_widget_get_allocated_height(GTK_WIDGET(area)); fbo = -1; glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo); mpv_opengl_cb_draw(ctx->opengl_ctx, fbo, width, height); return TRUE; }
static gboolean get_child_position (GtkOverlay *overlay, GtkWidget *widget, GtkAllocation *allocation, GtkColorEditor *editor) { GtkRequisition req; GtkAllocation alloc; gint s, e; gtk_widget_get_preferred_size (widget, &req, NULL); allocation->x = 0; allocation->y = 0; allocation->width = req.width; allocation->height = req.height; if (widget == editor->priv->sv_popup) { if (gtk_widget_get_direction (GTK_WIDGET (overlay)) == GTK_TEXT_DIR_RTL) allocation->x = 0; else allocation->x = gtk_widget_get_allocated_width (GTK_WIDGET (overlay)) - req.width; allocation->y = req.height / 3; } else if (widget == editor->priv->h_popup) { gtk_widget_get_allocation (editor->priv->h_slider, &alloc); gtk_range_get_slider_range (GTK_RANGE (editor->priv->h_slider), &s, &e); if (gtk_widget_get_direction (GTK_WIDGET (overlay)) == GTK_TEXT_DIR_RTL) gtk_widget_translate_coordinates (editor->priv->h_slider, gtk_widget_get_parent (editor->priv->grid), - req.width, (s + e - req.height) / 2, &allocation->x, &allocation->y); else gtk_widget_translate_coordinates (editor->priv->h_slider, gtk_widget_get_parent (editor->priv->grid), alloc.width, (s + e - req.height) / 2, &allocation->x, &allocation->y); } else if (widget == editor->priv->a_popup) { gtk_widget_get_allocation (editor->priv->a_slider, &alloc); gtk_range_get_slider_range (GTK_RANGE (editor->priv->a_slider), &s, &e); gtk_widget_translate_coordinates (editor->priv->a_slider, gtk_widget_get_parent (editor->priv->grid), (s + e - req.width) / 2, - req.height, &allocation->x, &allocation->y); } else return FALSE; allocation->x = CLAMP (allocation->x, 0, gtk_widget_get_allocated_width (GTK_WIDGET (overlay)) - req.width); allocation->y = CLAMP (allocation->y, 0, gtk_widget_get_allocated_height (GTK_WIDGET (overlay)) - req.height); return TRUE; }
static void compute_viewport(window_state_t *state, viewport_t *v) { stream_t *stream = state->stream; double min; double max; double unit; compute_scale_factor(state, &v->sx, &v->sy); v->w = gtk_widget_get_allocated_width(state->drawing_area); v->h = gtk_widget_get_allocated_height(state->drawing_area); v->uox = 0.0f; v->uoy = 0.0f; v->udx = v->w; v->udy = v->h; v->uw = v->w; v->uh = v->h; v->updx = 1.0f; v->updy = 1.0f; // Find equivalent for the origin and window size in user coordinates cairo_matrix_transform_point(&state->window_to_user_inv, &v->uox, &v->uoy); cairo_matrix_transform_point(&state->window_to_user_inv, &v->udx, &v->udy); cairo_matrix_transform_distance(&state->window_to_user_inv, &v->uw, &v->uh); cairo_matrix_transform_distance(&state->window_to_user_inv, &v->updx, &v->updy); v->sox = v->uox; v->soy = v->uoy; v->sdx = v->udx; v->sdy = v->udy; v->sw = v->uw; v->sh = v->uh; v->spdx = v->updx; v->spdy = v->updy; // Find equivalent for the origin and window size in scaled coordinates cairo_matrix_transform_point(&state->user_to_scaled_inv, &v->sox, &v->soy); cairo_matrix_transform_point(&state->user_to_scaled_inv, &v->sdx, &v->sdy); cairo_matrix_transform_distance(&state->user_to_scaled_inv, &v->sw, &v->sh); cairo_matrix_transform_distance(&state->user_to_scaled_inv, &v->spdx, &v->spdy); if (v->soy < v->sdy) { min = v->soy; max = v->sdy; } else { min = v->sdy; max = v->soy; } // Determine offsets of first wedge in view and first wedge out of view unit = state->wedge_height * stream->sample_rate / powf(2.0f, v->sy); v->start = floor((min * stream->sample_rate) / unit) * unit; v->end = (floor((max * stream->sample_rate) / unit) + 1.0f) * unit; v->skip = unit; // Offsets of stream v->stream_start = 0; v->stream_end = stream->n_samples; }
/** * gs_screenshot_image_draw: **/ static gboolean gs_screenshot_image_draw (GtkWidget *widget, cairo_t *cr) { GtkStyleContext *context; context = gtk_widget_get_style_context (widget); gtk_render_background (context, cr, 0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); gtk_render_frame (context, cr, 0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); return GTK_WIDGET_CLASS (gs_screenshot_image_parent_class)->draw (widget, cr); }
G_MODULE_EXPORT gboolean chart_da_draw_cb (GtkWidget *widget, cairo_t *cr, gpointer unused) { chart_draw (cr, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); return TRUE; }
static gboolean cvImageWidget_draw(GtkWidget* widget, cairo_t *cr, gpointer data) { #ifdef HAVE_OPENGL CvWindow* window = (CvWindow*)data; if (window->useGl) { drawGl(window); return TRUE; } #else (void)data; #endif CvImageWidget *image_widget = NULL; GdkPixbuf *pixbuf = NULL; g_return_val_if_fail (widget != NULL, FALSE); g_return_val_if_fail (CV_IS_IMAGE_WIDGET (widget), FALSE); image_widget = CV_IMAGE_WIDGET (widget); if( image_widget->scaled_image ){ // center image in available region int x0 = (gtk_widget_get_allocated_width(widget) - image_widget->scaled_image->cols)/2; int y0 = (gtk_widget_get_allocated_height(widget) - image_widget->scaled_image->rows)/2; pixbuf = gdk_pixbuf_new_from_data(image_widget->scaled_image->data.ptr, GDK_COLORSPACE_RGB, false, 8, MIN(image_widget->scaled_image->cols, gtk_widget_get_allocated_width(widget)), MIN(image_widget->scaled_image->rows, gtk_widget_get_allocated_height(widget)), image_widget->scaled_image->step, NULL, NULL); gdk_cairo_set_source_pixbuf(cr, pixbuf, x0, y0); } else if( image_widget->original_image ){ pixbuf = gdk_pixbuf_new_from_data(image_widget->original_image->data.ptr, GDK_COLORSPACE_RGB, false, 8, MIN(image_widget->original_image->cols, gtk_widget_get_allocated_width(widget)), MIN(image_widget->original_image->rows, gtk_widget_get_allocated_height(widget)), image_widget->original_image->step, NULL, NULL); gdk_cairo_set_source_pixbuf(cr, pixbuf, 0, 0); } cairo_paint(cr); g_object_unref(pixbuf); return TRUE; }
static gboolean drawing_area_draw (GtkWidget *widget, cairo_t *cr) { GtkStyleContext *context = gtk_widget_get_style_context (widget); gtk_render_background (context, cr, 0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); gtk_render_frame (context, cr, 0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); return FALSE; }
static void gtk_form_render_background(GtkWidget *widget, cairo_t *cr) { gtk_render_background(gtk_widget_get_style_context(widget), cr, 0, 0, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height(widget)); }
//! //! @brief To be written //! static void gw_kanjipadwindow_annotate_drawingarea_stroke (GwKanjipadWindow *window, GList *stroke, cairo_t *cr, gint index) { GwKanjipadWindowPrivate *priv; GdkPoint *cur, *old; // Annotate the stroke with the stroke number - the algorithm // for placing the digit is pretty simple. The text is inscribed // in a circle tangent to the stroke. The circle will be above // and/or to the left of the line priv = window->priv; if (stroke) { old = (GdkPoint *)stroke->data; do { cur = (GdkPoint *)stroke->data; stroke = stroke->next; } while (stroke && abs(cur->x - old->x) < 5 && abs (cur->y - old->y) < 5); if (stroke) { char buffer[16]; int swidth, sheight; gint16 x, y; double r; double dx = cur->x - old->x; double dy = cur->y - old->y; double dl = sqrt(dx*dx+dy*dy); int sign = (dy <= dx) ? 1 : -1; swidth = 0; sheight = 0; sprintf (buffer, "%d", index); r = sqrt(swidth*swidth + sheight*sheight); x = 0.5 + old->x + 0.5*r*dx/dl + sign * 0.5*r*dy/dl; y = 0.5 + old->y + 0.5*r*dy/dl - sign * 0.5*r*dx/dl; x -= swidth/2; y -= sheight/2; x = CLAMP (x, 0, gtk_widget_get_allocated_width (GTK_WIDGET (priv->drawingarea)) - swidth); y = CLAMP (y, 0, gtk_widget_get_allocated_height (GTK_WIDGET (priv->drawingarea)) - sheight); cairo_select_font_face (cr, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); cairo_set_source_rgb (cr, 1.0, 0.0, 0.0); cairo_set_font_size (cr, 10.0); cairo_move_to (cr, x, y); cairo_show_text (cr, buffer); cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); } } }
static gboolean on_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data) { if (surface != NULL) { cairo_surface_destroy(surface); } surface = gdk_window_create_similar_surface(gtk_widget_get_window(widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height(widget)); clear_surface(); return TRUE; }
static gboolean gdaui_bar_draw (GtkWidget *widget, cairo_t *cr) { GtkStyleContext *context; context = gtk_widget_get_style_context (widget); gtk_render_background (context, cr, 0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); gtk_render_frame (context, cr, 0, 0, gtk_widget_get_allocated_width (widget), gtk_widget_get_allocated_height (widget)); GTK_WIDGET_CLASS (parent_class)->draw (widget, cr); return FALSE; }
static void menu_position_cb (GtkMenu * menu, int * x, int * y, int * push, void * button) { int xorig, yorig, xwin, ywin; gdk_window_get_origin (gtk_widget_get_window (window), & xorig, & yorig); gtk_widget_translate_coordinates (button, window, 0, 0, & xwin, & ywin); * x = xorig + xwin; * y = yorig + ywin + gtk_widget_get_allocated_height (button); * push = TRUE; }
gboolean ks_chart_draw(GtkWidget * widget, cairo_t * cr, KsChart * data) { gint width = gtk_widget_get_allocated_width(widget); gint height = gtk_widget_get_allocated_height(widget); cairo_set_source_rgb(cr, 1.0, 1.0, 1.0); cairo_rectangle(cr, 0, 0, width, height); cairo_fill(cr); return TRUE; }
static gboolean on_draw (GtkWidget *widget, cairo_t *cr, gpointer *data) { slope_rect_t rect; rect.x = 0.0; rect.y = 0.0; rect.width = (double) gtk_widget_get_allocated_width(widget); rect.height = (double) gtk_widget_get_allocated_height(widget); slope_scene_t *scene = (slope_scene_t*) data; slope_scene_draw(scene, cr, &rect); return TRUE; }
/** * @brief Get dimention * * @param display gui_display instance * @param width memory to store width * @param height memory to store height * * @retval WG_SUCCESS * @retval WG_FAILURE */ wg_status gui_display_get_size(Gui_display *display, wg_uint *width, wg_uint *height) { CHECK_FOR_NULL_PARAM(display); CHECK_FOR_NULL_PARAM(width); CHECK_FOR_NULL_PARAM(height); *width = gtk_widget_get_allocated_width(display->widget); *height = gtk_widget_get_allocated_height(display->widget); return WG_SUCCESS; }
static void main_window_real_size_allocate (GtkWidget* base, GtkAllocation* allocation) { MainWindow * self; GtkAllocation _tmp0_; GtkBox* _tmp1_; self = (MainWindow*) base; g_return_if_fail (allocation != NULL); _tmp0_ = *allocation; GTK_WIDGET_CLASS (main_window_parent_class)->size_allocate ((GtkWidget*) G_TYPE_CHECK_INSTANCE_CAST (self, GTK_TYPE_WINDOW, GtkWindow), &_tmp0_); _tmp1_ = self->priv->hbox; if (_tmp1_ != NULL) { GtkBox* _tmp2_; gint _tmp3_ = 0; gint _tmp4_ = 0; GtkBox* _tmp5_; gint _tmp6_ = 0; gint _tmp7_ = 0; GtkBox* _tmp8_; gint _tmp9_ = 0; gint _tmp10_ = 0; GtkBox* _tmp11_; gint _tmp12_ = 0; gint _tmp13_ = 0; _tmp2_ = self->priv->hbox; _tmp3_ = gtk_widget_get_allocated_width ((GtkWidget*) self); _tmp4_ = get_grid_offset (_tmp3_); gtk_widget_set_margin_left ((GtkWidget*) _tmp2_, _tmp4_ + grid_size); _tmp5_ = self->priv->hbox; _tmp6_ = gtk_widget_get_allocated_width ((GtkWidget*) self); _tmp7_ = get_grid_offset (_tmp6_); gtk_widget_set_margin_right ((GtkWidget*) _tmp5_, _tmp7_); _tmp8_ = self->priv->hbox; _tmp9_ = gtk_widget_get_allocated_height ((GtkWidget*) self); _tmp10_ = get_grid_offset (_tmp9_); gtk_widget_set_margin_top ((GtkWidget*) _tmp8_, _tmp10_); _tmp11_ = self->priv->hbox; _tmp12_ = gtk_widget_get_allocated_height ((GtkWidget*) self); _tmp13_ = get_grid_offset (_tmp12_); gtk_widget_set_margin_bottom ((GtkWidget*) _tmp11_, _tmp13_); } }
static gboolean main_draw_callback(GtkWidget *widget, cairo_t *cr, gpointer data) { guint width, height; dt_lib_colorpicker_t *d = (dt_lib_colorpicker_t *)data; width = gtk_widget_get_allocated_width(widget); height = gtk_widget_get_allocated_height(widget); gdk_cairo_set_source_rgba (cr, &d->rgb); cairo_rectangle(cr, 0, 0, width, height); cairo_fill (cr); return FALSE; }
gboolean configure(GtkWidget *w, GdkEvent *event, gpointer data) { GtkLayout *l = (GtkLayout *) layout; gint width, height; gtk_window_get_size(GTK_WINDOW(w), &width, &height); if (layoutSize) { width = gtk_widget_get_allocated_width(layout); height = gtk_widget_get_allocated_height(layout); } resize(l, width, height); return FALSE; }