static void menu_position (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer entry) { GtkRequisition entry_request; GtkRequisition menu_request; GdkRectangle geometry; GdkScreen *screen; GtkWidget *toplevel = gtk_widget_get_toplevel (entry); gint monitor; gint x0; gint y0; gtk_widget_translate_coordinates (GTK_WIDGET (entry), toplevel, 0, 0, &x0, &y0); gtk_widget_size_request (GTK_WIDGET (entry), &entry_request); gtk_widget_size_request (GTK_WIDGET (menu), &menu_request); gdk_window_get_position (GTK_WIDGET (entry)->window, x, y); *x += x0 + gtk_container_get_border_width (GTK_CONTAINER (entry)); *y += y0 + (entry_request.height - gtk_container_get_border_width (GTK_CONTAINER (entry))); /* verify the the menu is on-screen */ screen = gtk_widget_get_screen (GTK_WIDGET (entry)); if (G_LIKELY (screen != NULL)) { monitor = gdk_screen_get_monitor_at_point (screen, *x, *y); gdk_screen_get_monitor_geometry (screen, monitor, &geometry); if (*y + menu_request.height > geometry.y + geometry.height) *y -= menu_request.height - entry_request.height; } *push_in = TRUE; }
GdkPixmap *make_pixmap(GtkScrollbox *self, gchar *value) { GdkWindow *rootwin; PangoLayout *pl; gint width, height, middle; GdkPixmap *pixmap; GtkRequisition widgsize = {0, }; GtkWidget *widget = (GtkWidget *)self; /* If we can't draw yet, don't do anything to avoid screwing things */ if (!GDK_IS_GC(widget->style->bg_gc[0])) return NULL; rootwin = gtk_widget_get_root_window(widget); pl = gtk_widget_create_pango_layout(widget, NULL); pango_layout_set_markup(pl, value, -1); pango_layout_get_pixel_size(pl, &width, &height); pixmap = gdk_pixmap_new(GDK_DRAWABLE(rootwin), width, height, -1); gdk_draw_rectangle(GDK_DRAWABLE(pixmap), widget->style->bg_gc[0], TRUE, 0, 0, width, height); gdk_draw_layout(GDK_DRAWABLE(pixmap), widget->style->fg_gc[0], 0, 0, pl); g_object_unref(pl); gtk_widget_size_request(widget, &widgsize); if (width <= widgsize.width) width = widgsize.width; if (height <= widgsize.height) height = widgsize.height; else self->draw_maxoffset = -height; if (width != widgsize.width || height != widgsize.height) gtk_widget_set_size_request(widget, width, height); middle = width / 2; if (self->draw_maxmiddle < middle) self->draw_maxmiddle = middle; return pixmap; }
static gboolean use_scrolled_window (GtkSourceCompletionInfo *info, GtkWidget *widget) { GtkRequisition req; gint mw; gint mh; mw = info->priv->max_width; mh = info->priv->max_height; gtk_widget_size_request (widget, &req); return (mw != -1 && mw < req.width) || (mh != -1 && mh < req.height); }
static gboolean avatar_image_expose_event (GtkWidget *widget, GdkEventExpose *event) { GiggleAvatarImagePriv *priv = GET_PRIV (widget); GtkAllocation allocation; GtkRequisition requisition; GtkStyle *style; float xalign, yalign; double x, y; int w, h; cairo_t *cr; gtk_widget_size_request (widget, &requisition); gtk_widget_get_allocation (widget, &allocation); style = gtk_widget_get_style (widget); cr = gdk_cairo_create (event->window); gdk_cairo_region (cr, event->region); cairo_clip (cr); w = requisition.width; h = requisition.height; gtk_misc_get_alignment (GTK_MISC (widget), &xalign, &yalign); cairo_translate (cr, (int) ((allocation.width - w) * xalign), (int) ((allocation.height - h) * yalign)); rounded_rectangle (cr, 0.5, 0.5, w - 1, h - 1, MIN (w, h) * 0.2); gdk_cairo_set_source_color (cr, &style->base[GTK_STATE_NORMAL]); cairo_fill_preserve (cr); if (priv->pixbuf) { x = (w - gdk_pixbuf_get_width (priv->pixbuf)) * 0.5; y = (h - gdk_pixbuf_get_height (priv->pixbuf)) * 0.5; gdk_cairo_set_source_pixbuf (cr, priv->pixbuf, x, y); cairo_fill_preserve (cr); } gdk_cairo_set_source_color (cr, &style->text[GTK_STATE_NORMAL]); cairo_set_line_width (cr, 1); cairo_stroke (cr); cairo_destroy (cr); return TRUE; }
Explorer* explorer_new(IterativeMap *map, Animation *animation) { Explorer *self = EXPLORER(g_object_new(explorer_get_type(), NULL)); GtkWidget *editor, *window, *scroll; GtkRequisition win_req; self->animation = ANIMATION(g_object_ref(animation)); self->map = ITERATIVE_MAP(g_object_ref(map)); /* Create the parameter editor */ editor = parameter_editor_new(PARAMETER_HOLDER(map)); gtk_box_pack_start(GTK_BOX(glade_xml_get_widget(self->xml, "parameter_editor_box")), editor, FALSE, FALSE, 0); gtk_widget_show_all(editor); /* Create the view */ self->view = histogram_view_new(HISTOGRAM_IMAGER(map)); gtk_container_add(GTK_CONTAINER(glade_xml_get_widget(self->xml, "drawing_area_viewport")), self->view); gtk_widget_show_all(self->view); /* Set the initial render time */ on_render_time_changed(glade_xml_get_widget(self->xml, "render_time"), self); explorer_init_history(self); explorer_init_animation(self); explorer_init_tools(self); explorer_init_cluster(self); explorer_init_about(self); /* Start the iterative map rendering in the background, and get a callback every time a block * of calculations finish so we can update the GUI. */ iterative_map_start_calculation(self->map); g_signal_connect(G_OBJECT(self->map), "calculation-finished", G_CALLBACK(on_calculation_finished), self); /* Set the window's default size to include our default image size. * The cleanest way I know of to do this is to set the scrolled window's scrollbar policies * to 'never' and get the window's size requests, set them back to automatic, then set the * default size to that size request. */ window = glade_xml_get_widget(self->xml, "explorer_window"); scroll = glade_xml_get_widget(self->xml, "main_scrolledwindow"); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_widget_size_request(window, &win_req); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_window_set_default_size(GTK_WINDOW(window), win_req.width, win_req.height); gtk_widget_show(window); return self; }
static void gdl_dock_item_grip_size_request (GtkWidget *widget, GtkRequisition *requisition) { GtkRequisition child_requisition; GtkContainer *container; GdlDockItemGrip *grip; gint layout_height; g_return_if_fail (GDL_IS_DOCK_ITEM_GRIP (widget)); g_return_if_fail (requisition != NULL); container = GTK_CONTAINER (widget); grip = GDL_DOCK_ITEM_GRIP (widget); requisition->width = container->border_width * 2 + ALIGN_BORDER; requisition->height = container->border_width * 2; ensure_title_and_icon_pixbuf (grip); pango_layout_get_pixel_size (grip->_priv->title_layout, NULL, &layout_height); gtk_widget_size_request (grip->_priv->close_button, &child_requisition); requisition->width += child_requisition.width; layout_height = MAX (layout_height, child_requisition.height); gtk_widget_size_request (grip->_priv->iconify_button, &child_requisition); requisition->width += child_requisition.width; layout_height = MAX (layout_height, child_requisition.height); requisition->height += layout_height; if (grip->_priv->icon_pixbuf) { requisition->width += gdk_pixbuf_get_width (grip->_priv->icon_pixbuf) + 1; } }
static void acw_selection_changed_lcb(GtkTreeSelection * selection, Tacwin * acw) { GtkTreeModel *model; GtkTreeIter iter; BluefishTextView *master = BLUEFISH_TEXT_VIEW(acw->btv->master); DBG_AUTOCOMP("acw_selection_changed_lcb, in_fill=%d\n",acw->in_fill); if (acw->in_fill) return; if (!g_array_index(master->bflang->st->contexts, Tcontext, acw->contextnum).patternhash || !main_v->props.show_autocomp_reference) return; if (gtk_tree_selection_get_selected(selection, &model, &iter)) { gchar *key; gtk_tree_model_get(model, &iter, 1, &key, -1); if (key) { DBG_AUTOCOMP("lookup reference for %s\n",key); gint pattern_id = GPOINTER_TO_INT(g_hash_table_lookup (g_array_index (master->bflang->st->contexts, Tcontext, acw->contextnum).patternhash, key)); DBG_AUTOCOMP("got pattern_id %d for key %s\n",pattern_id, key); g_free(key); if (pattern_id && g_array_index(master->bflang->st->matches, Tpattern, pattern_id).reference) { GtkRequisition requisition; DBG_AUTOCOMP("acw_selection_changed_lcb, show %s\n", g_array_index(master->bflang->st->matches, Tpattern, pattern_id).reference); gtk_label_set_markup(GTK_LABEL(acw->reflabel), g_array_index(master->bflang->st->matches, Tpattern, pattern_id).reference); gtk_widget_show(acw->reflabel); #if GTK_CHECK_VERSION(3,0,0) gtk_widget_get_preferred_size(acw->reflabel, &requisition, NULL); #else gtk_widget_size_request(acw->reflabel, &requisition); #endif /*gtk_window_get_size(GTK_WINDOW(acw->win),&width,&height); */ acw->w = acw->listwidth + requisition.width + 2; gtk_widget_set_size_request(acw->win, acw->w, (acw->h<350)?350:-1); return; } } } gtk_widget_hide(acw->reflabel); acw->w = acw->listwidth; gtk_widget_set_size_request(acw->win, acw->listwidth, -1); }
void gitg_utils_menu_position_under_tree_view (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer user_data) { GtkTreeView *tree = GTK_TREE_VIEW (user_data); GtkTreeModel *model; GtkTreeSelection *selection; GtkTreeIter iter; model = gtk_tree_view_get_model (tree); g_return_if_fail (model != NULL); selection = gtk_tree_view_get_selection (tree); g_return_if_fail (selection != NULL); if (gtk_tree_selection_get_selected (selection, NULL, &iter)) { GtkTreePath *path; GdkRectangle rect; gdk_window_get_origin (GTK_WIDGET (tree)->window, x, y); path = gtk_tree_model_get_path (model, &iter); gtk_tree_view_get_cell_area (tree, path, gtk_tree_view_get_column (tree, 0), /* FIXME 0 for RTL ? */ &rect); gtk_tree_path_free (path); *x += rect.x; *y += rect.y + rect.height; if (gtk_widget_get_direction (GTK_WIDGET (tree)) == GTK_TEXT_DIR_RTL) { GtkRequisition requisition; gtk_widget_size_request (GTK_WIDGET (menu), &requisition); *x += rect.width - requisition.width; } } else { /* no selection -> regular "under widget" positioning */ gitg_utils_menu_position_under_widget (menu, x, y, push_in, tree); } }
int TextWidth(const char *str) { // Uses a dummy label widget to retrieve the requested width from str static GtkWidget *lab = NULL; if (!lab) lab = gtk_label_new(str); else gtk_label_set(GTK_LABEL(lab), str); GtkRequisition req; gtk_widget_size_request(lab, &req); return req.width; }
int gSlider::getDefaultSize() { GtkRequisition req; #ifdef GTK3 gtk_widget_get_preferred_size(widget, &req, NULL); #else gtk_widget_size_request(widget, &req); #endif if (width() < height()) return req.width; else return req.height; }
static gint cpufreq_applet_get_max_unit_width (CPUFreqApplet *applet) { GtkWidget *label; GtkRequisition req; gint w1, w2; if (applet->max_unit_width > 0) return applet->max_unit_width; label = gtk_label_new ("GHz"); gtk_widget_size_request (label, &req); w1 = req.width; gtk_label_set_text (GTK_LABEL (label), "MHz"); gtk_widget_size_request (label, &req); w2 = req.width; gtk_widget_destroy (label); applet->max_unit_width = MAX (w1, w2); return applet->max_unit_width; }
static void spectool_channel_size_request (GtkWidget *widget, GtkRequisition *requisition) { SpectoolWidget *wwidget = SPECTOOL_WIDGET(widget); requisition->width = 0; requisition->height = 25; if (GTK_BIN(wwidget)->child && GTK_WIDGET_VISIBLE(GTK_BIN(wwidget)->child)) { GtkRequisition child_requisition; gtk_widget_size_request(GTK_BIN(wwidget)->child, &child_requisition); requisition->width += child_requisition.width; requisition->height += child_requisition.height; } }
void notify_stack_add_window(NotifyStack* stack, GtkWindow* nw, gboolean new_notification) { GtkRequisition req; gint x, y; gtk_widget_size_request(GTK_WIDGET(nw), &req); notify_stack_shift_notifications(stack, nw, NULL, req.width, req.height + NOTIFY_STACK_SPACING, &x, &y); theme_move_notification(nw, x, y); if (new_notification) { g_signal_connect_swapped(G_OBJECT(nw), "destroy", G_CALLBACK(notify_stack_remove_window), stack); stack->windows = g_list_prepend(stack->windows, nw); } }
static void gtk_vkb_button_size_request (GtkWidget *widget, GtkRequisition *requisition) { GtkBin *bin = GTK_BIN(widget); requisition->width = 0; requisition->height = 0; if (bin->child && GTK_WIDGET_VISIBLE(bin->child)) { GtkRequisition child_requisition; gtk_widget_size_request(bin->child, &child_requisition); requisition->width += child_requisition.width; requisition->height += child_requisition.height; } }
static gint cpufreq_applet_get_max_unit_width (CPUFreqApplet *applet) { GtkWidget *label; #if !GTK_CHECK_VERSION (3, 0, 0) GtkRequisition req; #endif gint w1, w2; if (applet->max_unit_width > 0) return applet->max_unit_width; label = gtk_label_new ("GHz"); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_get_preferred_width (applet->label, &w1, NULL); #else gtk_widget_size_request (label, &req); w1 = req.width; #endif gtk_label_set_text (GTK_LABEL (label), "MHz"); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_get_preferred_width (applet->label, &w2, NULL); #else gtk_widget_size_request (label, &req); w2 = req.width; #endif gtk_widget_destroy (label); #if GTK_CHECK_VERSION (3, 0, 0) applet->max_unit_width = MAX (w1, w2)-1; #else applet->max_unit_width = MAX (w1, w2); #endif return applet->max_unit_width; }
static void matenu_menu_bar_real_size_request (GtkWidget* base, GtkRequisition* req) { MatenuMenuBar * self; GtkRequisition _tmp0_ = {0}; GtkRequisition r; self = (MatenuMenuBar*) base; r = (_tmp0_.width = 0, _tmp0_.height = 0, _tmp0_); GTK_WIDGET_CLASS (matenu_menu_bar_parent_class)->size_request ((GtkWidget*) GTK_MENU_BAR (self), req); gtk_widget_size_request ((GtkWidget*) self->priv->_overflown_arrow, &r); if (r.width > (*req).width) { (*req).width = r.width; } if (r.height > (*req).height) { (*req).height = r.height; } }
/** * eel_gtk_widget_get_preferred_dimensions: * @gtk_widget: The source GtkWidget. * * Return value: The widget's preferred dimensions. The preferred dimensions are * computed by calling the widget's 'size_request' method and thus * could potentially be expensive for complicated widgets. */ EelDimensions eel_gtk_widget_get_preferred_dimensions (GtkWidget *gtk_widget) { GtkRequisition requisition; EelDimensions preferred_dimensions; g_return_val_if_fail (GTK_IS_WIDGET (gtk_widget), eel_dimensions_empty); gtk_widget_size_request (gtk_widget, &requisition); preferred_dimensions.width = (int) requisition.width; preferred_dimensions.height = (int) requisition.height; return preferred_dimensions; }
static void sp_button_size_request(GtkWidget *widget, GtkRequisition *requisition) { GtkWidget *child = gtk_bin_get_child(GTK_BIN(widget)); GtkStyle *style = gtk_widget_get_style(widget); if (child) { gtk_widget_size_request(GTK_WIDGET(child), requisition); } else { requisition->width = 0; requisition->height = 0; } requisition->width += 2 + 2 * MAX(2, style->xthickness); requisition->height += 2 + 2 * MAX(2, style->ythickness); }
static void constrain_list_size (GtkWidget *widget, GtkRequisition *requisition, GtkWidget *to_size) { GtkRequisition req; int max_height; /* Constrain height to be the tree height up to a max */ max_height = (gdk_screen_get_height (gtk_widget_get_screen (widget))) / 4; gtk_widget_size_request (to_size, &req); requisition->height = MIN (req.height, max_height); }
static void gtk_combo_button_get_pos (GtkComboButton * combo_button, gint * x, gint * y, gint * height, gint * width) { GtkBin *popwin; GtkWidget *widget; gint real_height, real_width; GtkRequisition child_requisition; gint avail_height, avail_width; gint min_height, min_width; gint work_width; gint work_height; widget = GTK_WIDGET(combo_button); popwin = GTK_BIN (combo_button->popwin); gdk_window_get_origin (combo_button->button->window, x, y); *x += combo_button->button->allocation.x; *y += combo_button->button->allocation.y; real_height = combo_button->button->allocation.height; real_width = combo_button->button->allocation.width + combo_button->arrow->allocation.width; *y += real_height; avail_height = gdk_screen_height () - *y; avail_width = gdk_screen_width() - *x; gtk_widget_size_request (combo_button->frame, &child_requisition); min_height = child_requisition.height; min_width = child_requisition.width; work_width = work_height = 0; if(work_height+child_requisition.height > avail_height) if(work_height + min_height > avail_height && *y - real_height > avail_height) *y -= (work_height + child_requisition.height + real_height); if(work_width+child_requisition.width > avail_width) if(work_width + min_width > avail_width && *x - real_width > avail_width) *x = *x + real_width - (work_width + child_requisition.width); *width = work_width + child_requisition.width; *height = work_height + child_requisition.height; }
static gint cpufreq_applet_get_max_label_width (CPUFreqApplet *applet) { GList *available_freqs; gint width = 0; if (applet->max_label_width > 0) return applet->max_label_width; if (!CPUFREQ_IS_MONITOR (applet->monitor)) return 0; available_freqs = cpufreq_monitor_get_available_frequencies (applet->monitor); while (available_freqs) { GtkWidget *label; #if GTK_CHECK_VERSION (3, 0, 0) gint label_width; #else GtkRequisition req; #endif const gchar *text; gchar *freq_text; gint freq; text = (const gchar *) available_freqs->data; freq = atoi (text); freq_text = cpufreq_utils_get_frequency_label (freq); label = gtk_label_new (freq_text); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_get_preferred_width (applet->label, &label_width, NULL); width = MAX (width, label_width); #endif #if !GTK_CHECK_VERSION (3, 0, 0) gtk_widget_size_request (label, &req); width = MAX (width, req.width); #endif g_free (freq_text); gtk_widget_destroy (label); available_freqs = g_list_next (available_freqs); } applet->max_label_width = width; return width; }
// Calculate the zoom ratio required to fit the whole image on the screen. float UI_calcZoomToFitScreen(GtkWindow* window, GtkWidget* drawingArea, uint32_t imageWidth, uint32_t imageHeight) { int windowWidth, windowHeight; int drawingWidth, drawingHeight; int reqWidth, reqHeight; uint32_t screenWidth, screenHeight; gtk_window_get_size(window, &windowWidth, &windowHeight); GtkRequisition size_req; gtk_widget_size_request (drawingArea, &size_req); drawingWidth = size_req.width; drawingHeight = size_req.height; gtk_widget_get_size_request(drawingArea, &reqWidth, &reqHeight); // Take borders and captions into consideration (GTK doesn't seem to // support this so we'll have to guess) windowWidth += 10; windowHeight += 10; // Take drawing area out of the equation, how much extra do we need for additional controls? // and then how much does that leave us for the image? uint32_t availableWidth = maxWindowWidth - (windowWidth - drawingWidth); uint32_t availableHeight = maxWindowHeight - (windowHeight - drawingHeight); float ratio; // Calculate zoom ratio if (imageWidth > availableWidth || imageHeight > availableHeight) { float wratio = (imageWidth <= availableWidth) ? 1 : (float (availableWidth) / float (imageWidth)); float hratio = (imageHeight <= availableHeight) ? 1 : (float (availableHeight) / float (imageHeight)); if (wratio < hratio) ratio = wratio; else ratio = hratio; } else ratio = 1; printf ("UI_calcZoomToFitScreen(): max %dx%d, win %dx%d, drawarea %dx%d (%dx%d), " "available %dx%d, image %dx%d, scale %.6f\n", maxWindowWidth, maxWindowHeight, windowWidth, windowHeight, drawingWidth, drawingHeight, reqWidth, reqHeight, availableWidth, availableHeight, imageWidth, imageHeight, ratio); return ratio; }
static void menu_position (GtkMenu *menu, gint *x, gint *y, gboolean *push_in, PlumaDocumentsPanel *panel) { GtkTreePath *path; GdkRectangle rect; gint wx, wy; GtkAllocation allocation; GtkRequisition requisition; GtkWidget *w; w = panel->priv->treeview; gtk_widget_get_allocation(w, &allocation); path = get_current_path (panel); gtk_tree_view_get_cell_area (GTK_TREE_VIEW (w), path, NULL, &rect); wx = rect.x; wy = rect.y; gdk_window_get_origin (gtk_widget_get_window (w), x, y); gtk_widget_size_request (GTK_WIDGET (menu), &requisition); if (gtk_widget_get_direction (w) == GTK_TEXT_DIR_RTL) { *x += allocation.x + allocation.width - requisition.width - 10; } else { *x += allocation.x + 10; } wy = MAX (*y + 5, *y + wy + 5); wy = MIN (wy, *y + allocation.height - requisition.height - 5); *y = wy; *push_in = TRUE; }
static void popup_button_position (PlannerPopupButton *button, gint *x, gint *y) { PlannerPopupButtonPriv *priv; GtkWidget *button_widget; GtkRequisition popup_req; GdkScreen *screen; gint monitor_num; GdkRectangle monitor; priv = GET_PRIV (button); button_widget = GTK_WIDGET (button); gdk_window_get_origin (button_widget->window, x, y); if (! gtk_widget_get_has_window (button_widget)) { *x += button_widget->allocation.x; *y += button_widget->allocation.y; } /* The popup should be placed below the button, right-aligned to it. */ *y += button_widget->allocation.height; *x += button_widget->allocation.width; gtk_widget_size_request (priv->popup_widget, &popup_req); *x -= popup_req.width; /* Don't popup outside the monitor edges. */ screen = gtk_widget_get_screen (GTK_WIDGET (button)); monitor_num = gdk_screen_get_monitor_at_window ( screen, GTK_WIDGET (button)->window); gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor); if (*x < monitor.x) { *x = monitor.x; } else if (*x + popup_req.width > monitor.x + monitor.width) { *x = monitor.x + monitor.width - popup_req.width; } if (*y + popup_req.height > monitor.y + monitor.height) { *y -= popup_req.height + button_widget->allocation.height; } }
static void tab_completion_popup_pos_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data) { TabCompData *td = data; gint height; PangoLayout *layout; PangoRectangle strong_pos, weak_pos; gint length; gint xoffset, yoffset; GtkRequisition req; GdkScreen *screen; gint monitor_num; GdkRectangle monitor; GtkRequisition requisition; GtkAllocation allocation; gdk_window_get_origin(gtk_widget_get_window(GTK_WIDGET(td->entry)), x, y); screen = gtk_widget_get_screen(GTK_WIDGET(menu)); monitor_num = gdk_screen_get_monitor_at_window(screen, gtk_widget_get_window(GTK_WIDGET(td->entry))); gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor); gtk_widget_size_request(GTK_WIDGET(menu), &req); length = strlen(gtk_entry_get_text(GTK_ENTRY(td->entry))); gtk_entry_get_layout_offsets(GTK_ENTRY(td->entry), &xoffset, &yoffset); layout = gtk_entry_get_layout(GTK_ENTRY(td->entry)); pango_layout_get_cursor_pos(layout, length, &strong_pos, &weak_pos); *x += strong_pos.x / PANGO_SCALE + xoffset; gtk_widget_get_requisition(td->entry, &requisition); gtk_widget_get_allocation(td->entry, &allocation); height = MIN(requisition.height, allocation.height); if (req.height > monitor.y + monitor.height - *y - height && *y - monitor.y > monitor.y + monitor.height - *y) { height = MIN(*y - monitor.y, req.height); gtk_widget_set_size_request(GTK_WIDGET(menu), -1, height); *y -= height; } else { *y += height; } }
static int get_popup_height (GnomeCanvasItem *item, int space_available, int row_height, gpointer user_data) { GtkWidget *cal = GTK_WIDGET (GNC_DATE_PICKER (item)->calendar); GtkRequisition req; req.height = 0; req.width = 0; gtk_widget_size_request (cal, &req); return req.height; }
static gint cpufreq_applet_get_max_perc_width (CPUFreqApplet *applet) { GtkWidget *label; GtkRequisition req; if (applet->max_perc_width > 0) return applet->max_perc_width; label = gtk_label_new ("100%"); gtk_widget_size_request (label, &req); applet->max_perc_width = req.width; gtk_widget_destroy (label); return applet->max_perc_width; }
static void gtk_mirror_bin_size_request (GtkWidget *widget, GtkRequisition *requisition) { GtkMirrorBin *bin = GTK_MIRROR_BIN (widget); GtkRequisition child_requisition; child_requisition.width = 0; child_requisition.height = 0; if (bin->child && gtk_widget_get_visible (bin->child)) gtk_widget_size_request (bin->child, &child_requisition); requisition->width = GTK_CONTAINER (widget)->border_width * 2 + child_requisition.width + 10; requisition->height = GTK_CONTAINER (widget)->border_width * 2 + child_requisition.height * 2 + 10; }
gboolean greeter_item_ulist_setup (void) { GreeterItemInfo *info; info = greeter_lookup_id ("user-pw-entry"); if (info && info->item && GNOME_IS_CANVAS_WIDGET (info->item) && GTK_IS_ENTRY (GNOME_CANVAS_WIDGET (info->item)->widget)) { pam_entry = GNOME_CANVAS_WIDGET (info->item)->widget; } info = greeter_lookup_id ("userlist"); if (info && info->item && GNOME_IS_CANVAS_WIDGET (info->item)) { GtkWidget *sw = GNOME_CANVAS_WIDGET (info->item)->widget; if (GTK_IS_SCROLLED_WINDOW (sw) && GTK_IS_TREE_VIEW (GTK_BIN (sw)->child)) { GtkRequisition req; gdouble height; user_list = GTK_BIN (sw)->child; force_no_tree_separators (user_list); greeter_generate_userlist (user_list, info); /* Reset size of the widget canvas item so it * is the same size as the userlist. This * avoids the ugly white background displayed * below the Face Browser when the list isn't * as large as the rectangle defined in the * MDM theme file. */ gtk_widget_size_request (user_list, &req); g_object_get (info->item, "height", &height, NULL); if (req.height < height) g_object_set (info->item, "height", (double)req.height, NULL); } } return TRUE; }
/** * gimp_menu_position: * @menu: a #GtkMenu widget * @x: pointer to horizontal position * @y: pointer to vertical position * * Positions a #GtkMenu so that it pops up on screen. This function * takes care of the preferred popup direction (taken from the widget * render direction) and it handles multiple monitors representing a * single #GdkScreen (Xinerama). * * You should call this function with @x and @y initialized to the * origin of the menu. This is typically the center of the widget the * menu is popped up from. gimp_menu_position() will then decide if * and how these initial values need to be changed. **/ void gimp_menu_position (GtkMenu *menu, gint *x, gint *y) { GtkWidget *widget; GdkScreen *screen; GtkRequisition requisition; GdkRectangle rect; gint monitor; g_return_if_fail (GTK_IS_MENU (menu)); g_return_if_fail (x != NULL); g_return_if_fail (y != NULL); widget = GTK_WIDGET (menu); screen = gtk_widget_get_screen (widget); monitor = gdk_screen_get_monitor_at_point (screen, *x, *y); gdk_screen_get_monitor_geometry (screen, monitor, &rect); gtk_menu_set_screen (menu, screen); gtk_widget_size_request (widget, &requisition); if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) { *x -= requisition.width; if (*x < rect.x) *x += requisition.width; } else { if (*x + requisition.width > rect.x + rect.width) *x -= requisition.width; } if (*x < rect.x) *x = rect.x; if (*y + requisition.height > rect.y + rect.height) *y -= requisition.height; if (*y < rect.y) *y = rect.y; }