static void mode_change (UmAccountDialog *self, UmAccountMode mode) { GtkWidget *button; gint visible_count = 0; gboolean active; gint i; g_assert (!self->mode_updating); self->mode_updating = TRUE; for (i = 0; i < NUM_MODES; i++) { button = self->mode_buttons[i]; active = (i == (gint)mode); /* The toggle state */ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)) != active) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), active); /* Make toggled buttons bold */ label_set_bold (GTK_LABEL (gtk_bin_get_child (GTK_BIN (button))), active); /* Show the correct area */ gtk_widget_set_visible (GTK_WIDGET (self->mode_areas[i]), active); if (gtk_widget_get_visible (button)) visible_count++; } /* Show mode container if more than one visible */ gtk_widget_set_visible (GTK_WIDGET (self->mode_container), visible_count > 1); self->mode = mode; self->mode_updating = FALSE; dialog_validate (self); }
static void gtk_image_menu_item_get_preferred_height_for_width (GtkWidget *widget, gint width, gint *minimum, gint *natural) { GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget); GtkImageMenuItemPrivate *priv = image_menu_item->priv; gint child_height = 0; GtkPackDirection pack_dir; GtkWidget *parent; parent = gtk_widget_get_parent (widget); if (GTK_IS_MENU_BAR (parent)) pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent)); else pack_dir = GTK_PACK_DIRECTION_LTR; if (priv->image && gtk_widget_get_visible (priv->image)) { GtkRequisition child_requisition; gtk_widget_get_preferred_size (priv->image, &child_requisition, NULL); child_height = child_requisition.height; } GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->get_preferred_height_for_width (widget, width, minimum, natural); if (pack_dir == GTK_PACK_DIRECTION_RTL || pack_dir == GTK_PACK_DIRECTION_LTR) { *minimum = MAX (*minimum, child_height); *natural = MAX (*natural, child_height); } }
static void to_parent_2 (GtkOffscreenBox *offscreen_box, double offscreen_x, double offscreen_y, double *x_out, double *y_out) { GtkAllocation child_area; double x, y, xr, yr; double cos_angle, sin_angle; gtk_widget_get_allocation (offscreen_box->child2, &child_area); x = offscreen_x; y = offscreen_y; x -= child_area.width / 2; y -= child_area.height / 2; cos_angle = cos (offscreen_box->angle); sin_angle = sin (offscreen_box->angle); xr = x * cos_angle - y * sin_angle; yr = x * sin_angle + y * cos_angle; x = xr; y = yr; x += child_area.width / 2; y += child_area.height / 2; if (offscreen_box->child1 && gtk_widget_get_visible (offscreen_box->child1)) { gtk_widget_get_allocation (offscreen_box->child1, &child_area); y += child_area.height; } *x_out = x; *y_out = y; }
static void gtk_image_menu_item_toggle_size_request (GtkMenuItem *menu_item, gint *requisition) { GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (menu_item); GtkPackDirection pack_dir; if (GTK_IS_MENU_BAR (GTK_WIDGET (menu_item)->parent)) pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (GTK_WIDGET (menu_item)->parent)); else pack_dir = GTK_PACK_DIRECTION_LTR; *requisition = 0; if (image_menu_item->image && gtk_widget_get_visible (image_menu_item->image)) { GtkRequisition image_requisition; guint toggle_spacing; gtk_widget_get_child_requisition (image_menu_item->image, &image_requisition); gtk_widget_style_get (GTK_WIDGET (menu_item), "toggle-spacing", &toggle_spacing, NULL); if (pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL) { if (image_requisition.width > 0) *requisition = image_requisition.width + toggle_spacing; } else { if (image_requisition.height > 0) *requisition = image_requisition.height + toggle_spacing; } } }
GtkWidget* do_assistant (GtkWidget *do_widget) { if (!assistant) { assistant = gtk_assistant_new (); gtk_window_set_default_size (GTK_WINDOW (assistant), -1, 300); gtk_window_set_screen (GTK_WINDOW (assistant), gtk_widget_get_screen (do_widget)); create_page1 (assistant); create_page2 (assistant); create_page3 (assistant); create_page4 (assistant); g_signal_connect (G_OBJECT (assistant), "cancel", G_CALLBACK (on_assistant_close_cancel), &assistant); g_signal_connect (G_OBJECT (assistant), "close", G_CALLBACK (on_assistant_close_cancel), &assistant); g_signal_connect (G_OBJECT (assistant), "apply", G_CALLBACK (on_assistant_apply), NULL); g_signal_connect (G_OBJECT (assistant), "prepare", G_CALLBACK (on_assistant_prepare), NULL); } if (!gtk_widget_get_visible (assistant)) gtk_widget_show (assistant); else { gtk_widget_destroy (assistant); assistant = NULL; } return assistant; }
void tab_event (gboolean shift) //FIXME: put prototype for this function //in some header file { gboolean is_visible = FALSE; g_object_get (window, "visible", &is_visible, NULL); if(is_visible) { GtkWidget **bs; guint bsize = 0; if(gtk_widget_get_visible (search)) { bs = filtered_boxes; bsize = filtered_size; } else { bs = boxes; bsize = wsize; } if (bsize == 0) return; // nothing to switch between // Calculate current box by straightforward pointer comparison guint current_box = 0; MosaicWindowBox* box = MOSAIC_WINDOW_BOX (gtk_window_get_focus (GTK_WINDOW (window))); for (guint i = 0; i < bsize; i++) if (MOSAIC_WINDOW_BOX(box) == MOSAIC_WINDOW_BOX(bs[i])) { current_box = i; break; } if(!shift) { current_box < bsize-1 ? current_box++ : (current_box = 0); } else { current_box > 0 ? current_box-- : (current_box = bsize-1); } gtk_widget_grab_focus (bs[current_box]); } else { update_box_list(); draw_mosaic (GTK_LAYOUT (layout), boxes, wsize, 0, options.box_width, options.box_height); gtk_window_present (GTK_WINDOW (window)); } }
static gboolean on_tray_activate(GtkStatusIcon *status_icon, gpointer data) { XmrTrayIcon *tray = XMR_TRAY_ICON(status_icon); XmrTrayIconPrivate *priv = tray->priv; if (priv->main_window == NULL) { return FALSE; } if (gtk_widget_get_visible(priv->main_window)) { gtk_widget_hide(priv->main_window); } else { gtk_widget_show(priv->main_window); gtk_window_present(GTK_WINDOW(priv->main_window)); } return FALSE; }
static gboolean awn_tooltip_show (AwnTooltip *tooltip, GdkEventCrossing *event, GtkWidget *focus) { g_return_val_if_fail (AWN_IS_TOOLTIP (tooltip), FALSE); AwnTooltipPrivate *priv = tooltip->priv; if (!priv->text || priv->show_timer_id || !priv->smart_behavior || priv->inhibit_show) return FALSE; if (priv->hide_timer_id) { g_source_remove (priv->hide_timer_id); priv->hide_timer_id = 0; return FALSE; } if (gtk_widget_get_visible (GTK_WIDGET (tooltip))) return FALSE; /* always use timer to show the widget, because there's a show/hide race * condition when mouse moves on the tooltip, leave-notify-event is generated * -> tooltip hides, then enter-notify-event from the widget is generated, * tooltip shows, therefore looping in an infinite loop * with the timer X-server at least doesn't stall */ if (!priv->show_timer_id) { gint delay = priv->delay > 0 ? priv->delay : 10; priv->show_timer_id = g_timeout_add(delay, awn_tooltip_show_timer, tooltip); } return FALSE; }
static void panel_frame_get_preferred_width (GtkWidget *widget, gint *minimal_width, gint *natural_width) { PanelFrame *frame = (PanelFrame *) widget; GtkBin *bin = (GtkBin *) widget; GtkStyleContext *context; GtkWidget *child; GtkBorder padding; int border_width; context = gtk_widget_get_style_context (widget); gtk_style_context_get_padding (context, gtk_widget_get_state_flags (widget), &padding); border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); *minimal_width = 1; *natural_width = 1; child = gtk_bin_get_child (bin); if (child && gtk_widget_get_visible (child)) gtk_widget_get_preferred_width (child, minimal_width, natural_width); *minimal_width += border_width; *natural_width += border_width; if (frame->edges & PANEL_EDGE_LEFT) { *minimal_width += padding.left; *natural_width += padding.left; } if (frame->edges & PANEL_EDGE_RIGHT) { *minimal_width += padding.right; *natural_width += padding.right; } }
void gtr_widget_set_visible (GtkWidget * w, gboolean b) { /* toggle the transient children, too */ if (GTK_IS_WINDOW (w)) { GList * l; GList * windows = gtk_window_list_toplevels (); GtkWindow * window = GTK_WINDOW (w); for (l=windows; l!=NULL; l=l->next) { if (!GTK_IS_WINDOW (l->data)) continue; if (gtk_window_get_transient_for (GTK_WINDOW (l->data)) != window) continue; if (gtk_widget_get_visible (GTK_WIDGET (l->data)) == b) continue; if (b && g_object_get_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN) != NULL) { g_object_steal_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN); gtr_widget_set_visible (GTK_WIDGET (l->data), TRUE); } else if (!b) { g_object_set_data (G_OBJECT (l->data), GTR_CHILD_HIDDEN, GINT_TO_POINTER (1)); gtr_widget_set_visible (GTK_WIDGET (l->data), FALSE); } } g_list_free (windows); } gtk_widget_set_visible (w, b); }
static gboolean uber_window_graph_button_press_event (GtkWidget *widget, /* IN */ GdkEventButton *button, /* IN */ UberWindow *window) /* IN */ { GtkWidget *labels; g_return_val_if_fail(UBER_IS_WINDOW(window), FALSE); g_return_val_if_fail(UBER_IS_GRAPH(widget), FALSE); switch (button->button) { case 1: /* Left click */ labels = uber_graph_get_labels(UBER_GRAPH(widget)); if (gtk_widget_get_visible(labels)) { uber_window_hide_labels(window, UBER_GRAPH(widget)); } else { uber_window_show_labels(window, UBER_GRAPH(widget)); } break; default: break; } return FALSE; }
static void gstyle_slidein_overlay_child_allocate (GstyleSlidein *self, GtkAllocation *alloc) { GtkAllocation child_alloc = { 0, }; gboolean visible; g_assert (GSTYLE_IS_SLIDEIN (self)); g_assert (alloc != NULL); if (self->overlay_child != NULL) { visible = gtk_widget_get_visible (self->overlay_child); if (self->overlay_window != NULL && gtk_widget_get_mapped (GTK_WIDGET (self))) { if (visible) gdk_window_show (self->overlay_window); else if (gdk_window_is_visible (self->overlay_window)) gdk_window_hide (self->overlay_window); } if (!visible) return; gstyle_slidein_compute_child_allocation (self, *alloc, &child_alloc); if (self->overlay_window != NULL) gdk_window_move_resize (self->overlay_window, child_alloc.x, child_alloc.y, child_alloc.width, child_alloc.height); child_alloc.x = 0; child_alloc.y = 0; gtk_widget_size_allocate (self->overlay_child, &child_alloc); } }
static void eel_wrap_table_unmap (GtkWidget *widget) { EelWrapTable *wrap_table; GList *iterator; g_assert (EEL_IS_WRAP_TABLE (widget)); wrap_table = EEL_WRAP_TABLE (widget); gtk_widget_set_mapped (widget, FALSE); for (iterator = wrap_table->details->children; iterator; iterator = iterator->next) { GtkWidget *item; item = iterator->data; if (gtk_widget_get_visible (item) && gtk_widget_get_mapped (item)) { gtk_widget_unmap (item); } } }
static GWENHYWFAR_CB int Gtk3Gui_WGroupBox_GetIntProperty(GWEN_WIDGET *w, GWEN_DIALOG_PROPERTY prop, int index, int defaultValue) { GtkWidget *g; g=GTK_WIDGET(GWEN_Widget_GetImplData(w, GTK3_DIALOG_WIDGET_REAL)); assert(g); switch (prop) { case GWEN_DialogProperty_Enabled: return (gtk_widget_get_sensitive(GTK_WIDGET(g))==TRUE)?1:0; case GWEN_DialogProperty_Focus: return (gtk_widget_has_focus(GTK_WIDGET(g))==TRUE)?1:0; return 0; case GWEN_DialogProperty_Width: case GWEN_DialogProperty_Height: /* just ignore these for now */ return 0; case GWEN_DialogProperty_Visibility: return (gtk_widget_get_visible(GTK_WIDGET(g))==TRUE)?1:0; default: break; } DBG_WARN(GWEN_LOGDOMAIN, "Function is not appropriate for this type of widget (%s)", GWEN_Widget_Type_toString(GWEN_Widget_GetType(w))); return defaultValue; }
/* After reading the documentation at * http://developer.gnome.org/doc/API/2.0/gtk/gtk-changes-2-0.html * I think it should be possible to remove this function when compiling * against gtk-2.0. It doesn't seem to cause problems, though. * * Well, I reckon at least the gdk_window_show(form->bin_window) * is necessary. GtkForm is anything but a usual container widget. */ static void gtk_form_map(GtkWidget *widget) { GList *tmp_list; GtkForm *form; g_return_if_fail(GTK_IS_FORM(widget)); form = GTK_FORM(widget); gtk_widget_set_mapped(widget, TRUE); gdk_window_show(gtk_widget_get_window(widget)); gdk_window_show(form->bin_window); for (tmp_list = form->children; tmp_list; tmp_list = tmp_list->next) { GtkFormChild *child = tmp_list->data; if (gtk_widget_get_visible(child->widget) && !gtk_widget_get_mapped(child->widget)) gtk_widget_map(child->widget); } }
void gimp_overlay_child_invalidate (GimpOverlayBox *box, GimpOverlayChild *child) { GdkWindow *window; g_return_if_fail (GIMP_IS_OVERLAY_BOX (box)); g_return_if_fail (child != NULL); window = gtk_widget_get_window (GTK_WIDGET (box)); if (window && gtk_widget_get_visible (child->widget)) { GtkAllocation child_allocation; GdkRectangle bounds; gtk_widget_get_allocation (child->widget, &child_allocation); gimp_overlay_child_transform_bounds (child, &child_allocation, &bounds); gdk_window_invalidate_rect (window, &bounds, FALSE); } }
void on_activate_requested (void) { if (toggle_mainwindow_action && 0) { toggle_mainwindow_action->callback2 (toggle_mainwindow_action, -1); } else { GtkWidget *mainwin = gtkui_plugin->get_mainwin (); GdkWindow *gdk_window = gtk_widget_get_window (mainwin); int iconified = gdk_window_get_state (gdk_window) & GDK_WINDOW_STATE_ICONIFIED; if (gtk_widget_get_visible (mainwin) && !iconified) { gtk_widget_hide (mainwin); } else { if (iconified) { gtk_window_deiconify (GTK_WINDOW (mainwin)); } else { gtk_window_present (GTK_WINDOW (mainwin)); } gdk_x11_window_force_focus (gdk_window, 0); } } }
/*********************************************** * gtk_menu_shell_leave - * * Leave signal to ensure menushell items * normal state on mouse leave. ***********************************************/ static gboolean glide_gtk2_engine_hack_menu_shell_leave(GtkWidget *widget, GdkEventCrossing *event, gpointer user_data) { if (GE_IS_MENU_SHELL(widget)) { GList *children = NULL, *child = NULL; if (GE_IS_CONTAINER(widget)) { children = gtk_container_get_children(GTK_CONTAINER(widget)); for (child = g_list_first(children); child; child = g_list_next(child)) { if ((child->data) && GE_IS_MENU_ITEM(child->data) && (gtk_widget_get_state (GTK_WIDGET(child->data)) != GTK_STATE_INSENSITIVE)) { GtkWidget *submenu; submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (child->data)); if ((!GE_IS_MENU(submenu)) || (!(gtk_widget_get_realized(submenu) && gtk_widget_get_visible (submenu)))) { gtk_widget_set_state (GTK_WIDGET(child->data), GTK_STATE_NORMAL); } } } if (children) g_list_free(children); } } return FALSE; }
static void gb_editor_tab_update_location (GbEditorTab *tab) { GbEditorTabPrivate *priv; GtkTextBuffer *buffer; GtkTextMark *mark; GtkTextIter iter; gboolean overwrite; gchar *text; guint line; guint column; g_return_if_fail(GB_IS_EDITOR_TAB(tab)); priv = tab->priv; buffer = GTK_TEXT_BUFFER(priv->document); overwrite = gtk_text_view_get_overwrite(GTK_TEXT_VIEW(priv->text_view)); mark = gtk_text_buffer_get_insert(buffer); gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark); line = gtk_text_iter_get_line(&iter) + 1; column = gtk_source_view_get_visual_column(GTK_SOURCE_VIEW(priv->text_view), &iter) + 1; if (!overwrite) { text = g_strdup_printf(_("Ln %u, Col %u INS"), line, column); } else { text = g_strdup_printf(_("Ln %u, Col %u REP"), line, column); } g_object_set(priv->floating_bar, "label", text, NULL); g_free(text); if (!gtk_widget_get_visible(priv->floating_bar)) { gtk_widget_show(priv->floating_bar); } }
void show_tabbed_viewer (windata_t *vwin) { tabwin_t *tabwin = vwin_get_tabwin(vwin); GtkNotebook *notebook = GTK_NOTEBOOK(tabwin->tabs); int np = gtk_notebook_get_n_pages(notebook); gtk_widget_show_all(vwin->main); if (np > 1) { int pgnum = gtk_notebook_page_num(notebook, vwin->main); gtk_notebook_set_current_page(notebook, pgnum); } #if GTK_MAJOR_VERSION == 2 && GTK_MAJOR_VERSION < 18 if (!GTK_WIDGET_VISIBLE(tabwin->main)) { gtk_widget_show_all(tabwin->main); } #else if (!gtk_widget_get_visible(tabwin->main)) { gtk_widget_show_all(tabwin->main); } #endif if (vwin->role == EDIT_SCRIPT) { gtk_drag_dest_set(vwin->text, GTK_DEST_DEFAULT_ALL, tabwin_drag_targets, 1, GDK_ACTION_COPY); g_signal_connect(G_OBJECT(vwin->text), "drag-data-received", G_CALLBACK(tabwin_handle_drag), tabwin); } gtk_window_present(GTK_WINDOW(tabwin->main)); }
static void debug_manager_notify_debugger (IdeDebuggerEditorAddin *self, GParamSpec *pspec, IdeDebugManager *debug_manager) { IdeDebugger *debugger; IdeWorkspace *workspace; g_assert (IDE_IS_DEBUGGER_EDITOR_ADDIN (self)); g_assert (IDE_IS_DEBUG_MANAGER (debug_manager)); if (!gtk_widget_get_visible (GTK_WIDGET (self->panel))) { GtkWidget *stack = gtk_widget_get_parent (GTK_WIDGET (self->panel)); gtk_widget_show (GTK_WIDGET (self->panel)); if (GTK_IS_STACK (stack)) gtk_stack_set_visible_child (GTK_STACK (stack), GTK_WIDGET (self->panel)); } debugger = ide_debug_manager_get_debugger (debug_manager); if ((workspace = ide_widget_get_workspace (GTK_WIDGET (self->editor)))) gtk_widget_insert_action_group (GTK_WIDGET (workspace), "debugger", G_ACTION_GROUP (debugger)); ide_debugger_breakpoints_view_set_debugger (self->breakpoints_view, debugger); ide_debugger_locals_view_set_debugger (self->locals_view, debugger); ide_debugger_libraries_view_set_debugger (self->libraries_view, debugger); ide_debugger_registers_view_set_debugger (self->registers_view, debugger); ide_debugger_threads_view_set_debugger (self->threads_view, debugger); dzl_signal_group_set_target (self->debugger_signals, debugger); }
GtkWidget * do_builder (GtkWidget *do_widget) { static GtkWidget *window = NULL; GError *err = NULL; if (!window) { builder = gtk_builder_new (); gtk_builder_add_from_resource (builder, "/builder/demo.ui", &err); if (err) { g_error ("ERROR: %s\n", err->message); return NULL; } gtk_builder_connect_signals (builder, NULL); window = GTK_WIDGET (gtk_builder_get_object (builder, "window1")); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); } if (!gtk_widget_get_visible (window)) { gtk_widget_show_all (window); } else { gtk_widget_destroy (window); window = NULL; } return window; }
GtkWidget * do_foreigndrawing (GtkWidget *do_widget) { static GtkWidget *window = NULL; if (!window) { GtkWidget *box; GtkWidget *da; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Foreign drawing"); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); gtk_container_add (GTK_CONTAINER (window), box); da = gtk_drawing_area_new (); gtk_widget_set_size_request (da, 200, 200); gtk_widget_set_hexpand (da, TRUE); gtk_widget_set_vexpand (da, TRUE); gtk_widget_set_app_paintable (da, TRUE); gtk_container_add (GTK_CONTAINER (box), da); g_signal_connect (da, "draw", G_CALLBACK (draw_cb), NULL); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); return window; }
gboolean view_command_active(void) { return gtk_widget_get_visible(command_dialog); }
static void gtk_image_menu_item_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { GtkImageMenuItem *image_menu_item = GTK_IMAGE_MENU_ITEM (widget); GtkImageMenuItemPrivate *priv = image_menu_item->priv; GtkAllocation widget_allocation; GtkPackDirection pack_dir; GtkWidget *parent; parent = gtk_widget_get_parent (widget); if (GTK_IS_MENU_BAR (parent)) pack_dir = gtk_menu_bar_get_child_pack_direction (GTK_MENU_BAR (parent)); else pack_dir = GTK_PACK_DIRECTION_LTR; GTK_WIDGET_CLASS (gtk_image_menu_item_parent_class)->size_allocate (widget, allocation); if (priv->image && gtk_widget_get_visible (priv->image)) { gint x, y, offset; GtkStyleContext *context; GtkStateFlags state; GtkBorder padding; GtkRequisition child_requisition; GtkAllocation child_allocation; guint horizontal_padding, toggle_spacing; gint toggle_size; toggle_size = GTK_MENU_ITEM (image_menu_item)->priv->toggle_size; gtk_widget_style_get (widget, "horizontal-padding", &horizontal_padding, "toggle-spacing", &toggle_spacing, NULL); /* Man this is lame hardcoding action, but I can't * come up with a solution that's really better. */ gtk_widget_get_preferred_size (priv->image, &child_requisition, NULL); gtk_widget_get_allocation (widget, &widget_allocation); context = gtk_widget_get_style_context (widget); state = gtk_widget_get_state_flags (widget); gtk_style_context_get_padding (context, state, &padding); offset = gtk_container_get_border_width (GTK_CONTAINER (image_menu_item)); if (pack_dir == GTK_PACK_DIRECTION_LTR || pack_dir == GTK_PACK_DIRECTION_RTL) { if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) == (pack_dir == GTK_PACK_DIRECTION_LTR)) x = offset + horizontal_padding + padding.left + (toggle_size - toggle_spacing - child_requisition.width) / 2; else x = widget_allocation.width - offset - horizontal_padding - padding.right - toggle_size + toggle_spacing + (toggle_size - toggle_spacing - child_requisition.width) / 2; y = (widget_allocation.height - child_requisition.height) / 2; } else { if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR) == (pack_dir == GTK_PACK_DIRECTION_TTB)) y = offset + horizontal_padding + padding.top + (toggle_size - toggle_spacing - child_requisition.height) / 2; else y = widget_allocation.height - offset - horizontal_padding - padding.bottom - toggle_size + toggle_spacing + (toggle_size - toggle_spacing - child_requisition.height) / 2; x = (widget_allocation.width - child_requisition.width) / 2; } child_allocation.width = child_requisition.width; child_allocation.height = child_requisition.height; child_allocation.x = widget_allocation.x + MAX (x, 0); child_allocation.y = widget_allocation.y + MAX (y, 0); gtk_widget_size_allocate (priv->image, &child_allocation); } }
GtkWidget * do_images (GtkWidget *do_widget) { GtkWidget *video; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *base_vbox; GtkWidget *image; GtkWidget *picture; GtkWidget *label; GtkWidget *button; GdkPaintable *paintable; GIcon *gicon; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Images"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); g_signal_connect (window, "destroy", G_CALLBACK (cleanup_callback), NULL); base_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); g_object_set (base_vbox, "margin", 16, NULL); gtk_container_add (GTK_CONTAINER (window), base_vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 16); gtk_container_add (GTK_CONTAINER (base_vbox), hbox); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (hbox), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Image loaded from a file</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); image = gtk_image_new_from_icon_name ("gtk3-demo"); gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE); gtk_container_add (GTK_CONTAINER (frame), image); /* Animation */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Animation loaded from a file</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); picture = gtk_picture_new_for_resource ("/images/floppybuddy.gif"); gtk_container_add (GTK_CONTAINER (frame), picture); /* Symbolic icon */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Symbolic themed icon</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic"); image = gtk_image_new_from_gicon (gicon); gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE); gtk_container_add (GTK_CONTAINER (frame), image); /* Progressive */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (hbox), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Progressive image loading</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); /* Create an empty image for now; the progressive loader * will create the pixbuf and fill it in. */ picture = gtk_picture_new (); gtk_container_add (GTK_CONTAINER (frame), picture); start_progressive_loading (picture); /* Video */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (hbox), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Displaying video</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); video = gtk_video_new_for_resource ("/images/gtk-logo.webm"); gtk_media_stream_set_loop (gtk_video_get_media_stream (GTK_VIDEO (video)), TRUE); gtk_container_add (GTK_CONTAINER (frame), video); /* Widget paintables */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (hbox), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>GtkWidgetPaintable</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); paintable = gtk_widget_paintable_new (do_widget); picture = gtk_picture_new_for_paintable (paintable); gtk_widget_set_size_request (picture, 100, 100); gtk_widget_set_valign (picture, GTK_ALIGN_START); gtk_container_add (GTK_CONTAINER (vbox), picture); /* Sensitivity control */ button = gtk_toggle_button_new_with_mnemonic ("_Insensitive"); gtk_container_add (GTK_CONTAINER (base_vbox), button); g_signal_connect (button, "toggled", G_CALLBACK (toggle_sensitivity_callback), base_vbox); } if (!gtk_widget_get_visible (window)) gtk_widget_show (window); else gtk_widget_destroy (window); return window; }
/* Convenience function for counting the number of visible * children, for use with g_list_foreach() */ static void count_visible_children(GtkWidget *widget, unsigned *n_visible_children) { if(gtk_widget_get_visible(widget)) (*n_visible_children)++; }
/* Allocate the sizes of the container's children */ static void p_square_size_allocate(GtkWidget *widget, GtkAllocation *allocation) { g_return_if_fail(widget != NULL || allocation != NULL); g_return_if_fail(P_IS_SQUARE(widget)); PSquarePrivate *priv = P_SQUARE_PRIVATE(widget); gtk_widget_set_allocation(widget, allocation); /* Calculate the number of columns (and rows) */ unsigned n_columns, n_rows; n_columns = n_rows = get_n_columns_and_rows(P_SQUARE(widget)); if(n_columns == 0) return; /* Calculate how much extra space we need */ unsigned border_width = gtk_container_get_border_width(GTK_CONTAINER(widget)); int extra_width = allocation->width - 2 * border_width; int extra_height = allocation->height - 2 * border_width; /* Follow the same procedure as in the size request to get * the ideal sizes of each column */ GtkRequestedSize *widths = get_group_sizes(P_SQUARE(widget), GTK_ORIENTATION_HORIZONTAL, n_columns); /* Distribute the extra space per column (can be negative) */ unsigned count; for(count = 0; count < n_columns; count++) extra_width -= widths[count].minimum_size; distribute_extra_space(P_SQUARE(widget), widths, extra_width, n_columns); /* Follow the same procedure for height, * now that we know the width */ GtkRequestedSize *heights = get_group_sizes_for_sizes(P_SQUARE(widget), GTK_ORIENTATION_VERTICAL, widths, n_rows); /* Distribute the extra space per row (can be negative) */ for(count = 0; count < n_rows; count++) extra_height -= heights[count].minimum_size; distribute_extra_space(P_SQUARE(widget), heights, extra_height, n_rows); /* Start positioning the items at the container's origin, * less the border width */ int x = allocation->x + border_width; int y = allocation->y + border_width; count = 0; GList *iter; for(iter = priv->children; iter; iter = g_list_next(iter)) { if(!gtk_widget_get_visible(iter->data)) continue; /* Give the child its allocation */ GtkAllocation child_allocation; child_allocation.x = x; child_allocation.y = y; child_allocation.width = widths[count % n_columns].minimum_size; child_allocation.height = heights[count / n_columns].minimum_size; gtk_widget_size_allocate(iter->data, &child_allocation); /* Advance the x coordinate */ x += child_allocation.width; count++; /* If we've moved to the next row, return the x coordinate * to the left, and advance the y coordinate */ if(count % n_columns == 0) { x = allocation->x + border_width; y += child_allocation.height; } } g_free(widths); g_free(heights); }
static void gnm_font_button_clicked (GtkButton *button) { GtkFontChooser *font_dialog; GnmFontButton *font_button = GNM_FONT_BUTTON (button); GnmFontButtonPrivate *priv = font_button->priv; if (!font_button->priv->font_dialog) { GtkWidget *parent; parent = gtk_widget_get_toplevel (GTK_WIDGET (font_button)); priv->font_dialog = g_object_new (priv->dialog_type, NULL); font_dialog = GTK_FONT_CHOOSER (font_button->priv->font_dialog); gtk_font_chooser_set_show_preview_entry (font_dialog, priv->show_preview_entry); if (priv->preview_text) { gtk_font_chooser_set_preview_text (font_dialog, priv->preview_text); g_free (priv->preview_text); priv->preview_text = NULL; } if (priv->font_filter) { gtk_font_chooser_set_filter_func (font_dialog, priv->font_filter, priv->font_filter_data, priv->font_filter_data_destroy); priv->font_filter = NULL; priv->font_filter_data = NULL; priv->font_filter_data_destroy = NULL; } if (gtk_widget_is_toplevel (parent) && GTK_IS_WINDOW (parent)) { if (GTK_WINDOW (parent) != gtk_window_get_transient_for (GTK_WINDOW (font_dialog))) gtk_window_set_transient_for (GTK_WINDOW (font_dialog), GTK_WINDOW (parent)); gtk_window_set_modal (GTK_WINDOW (font_dialog), gtk_window_get_modal (GTK_WINDOW (parent))); } g_signal_connect (font_dialog, "notify", G_CALLBACK (gnm_font_button_font_chooser_notify), button); g_signal_connect (font_dialog, "response", G_CALLBACK (response_cb), font_button); g_signal_connect (font_dialog, "destroy", G_CALLBACK (dialog_destroy), font_button); } if (!gtk_widget_get_visible (font_button->priv->font_dialog)) { font_dialog = GTK_FONT_CHOOSER (font_button->priv->font_dialog); gtk_font_chooser_set_font_desc (font_dialog, font_button->priv->font_desc); } gtk_window_present (GTK_WINDOW (font_button->priv->font_dialog)); }
GtkWidget * do_editable_cells (GtkWidget *do_widget) { if (!window) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *sw; GtkWidget *treeview; GtkWidget *button; GtkTreeModel *items_model; GtkTreeModel *numbers_model; /* create window, etc */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Shopping list"); gtk_container_set_border_width (GTK_CONTAINER (window), 5); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new ("Shopping list (you can edit the cells!)"), FALSE, FALSE, 0); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); /* create models */ items_model = create_items_model (); numbers_model = create_numbers_model (); /* create tree view */ treeview = gtk_tree_view_new_with_model (items_model); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)), GTK_SELECTION_SINGLE); add_columns (GTK_TREE_VIEW (treeview), items_model, numbers_model); g_object_unref (numbers_model); g_object_unref (items_model); gtk_container_add (GTK_CONTAINER (sw), treeview); /* some buttons */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_with_label ("Add item"); g_signal_connect (button, "clicked", G_CALLBACK (add_item), items_model); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); button = gtk_button_new_with_label ("Remove item"); g_signal_connect (button, "clicked", G_CALLBACK (remove_item), treeview); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_window_set_default_size (GTK_WINDOW (window), 320, 200); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else { gtk_widget_destroy (window); window = NULL; } return window; }