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;
}
