/**
* Create a box with a nice bold title and content slightly indented.
* All content is packed vertically in a GtkVBox. The paddingbox is
* also packed in its parent.
*
* \param parent Parent widget to pack paddingbox in
* \param fill Give all available space to padding box or not
* \param title Title to display on top of the paddingbox
*/
GtkWidget *new_paddingbox_with_title (GtkWidget *parent, gboolean fill, const gchar *title)
{
GtkWidget *vbox, *hbox, *paddingbox, *label;
gchar* tmp_str;
vbox = gtk_vbox_new ( FALSE, 6 );
if ( GTK_IS_BOX(parent) )
{
gtk_box_pack_start ( GTK_BOX ( parent ), vbox,
fill, fill, 0);
}
/* Creating label */
label = gtk_label_new ( NULL );
gtk_misc_set_alignment ( GTK_MISC ( label ), 0, 1 );
tmp_str = g_markup_printf_escaped ("<span weight=\"bold\">%s</span>", title );
gtk_label_set_markup ( GTK_LABEL ( label ), tmp_str );
g_free(tmp_str);
gtk_box_pack_start ( GTK_BOX ( vbox ), label,
FALSE, FALSE, 0);
gtk_widget_show ( label );
/* Creating horizontal box */
hbox = gtk_hbox_new ( FALSE, 0 );
gtk_box_pack_start ( GTK_BOX ( vbox ), hbox,
fill, fill, 0);
/* Some padding. ugly but the HiG advises it this way ;-) */
label = gtk_label_new ( " " );
gtk_box_pack_start ( GTK_BOX ( hbox ), label,
FALSE, FALSE, 0 );
/* Then make the vbox itself */
paddingbox = gtk_vbox_new ( FALSE, 6 );
gtk_box_pack_start ( GTK_BOX ( hbox ), paddingbox,
TRUE, TRUE, 0);
/* Put a label at the end to feed a new line */
/* label = gtk_label_new ( " " ); */
/* gtk_box_pack_end ( GTK_BOX ( paddingbox ), label, */
/* FALSE, FALSE, 0 ); */
if ( GTK_IS_BOX(parent) )
{
gtk_box_set_spacing ( GTK_BOX(parent), 18 );
}
return paddingbox;
}
void tab_completion_add_select_button(GtkWidget *entry, const gchar *title, gboolean folders_only)
{
TabCompData *td;
GtkWidget *parent;
GtkWidget *hbox;
td = g_object_get_data(G_OBJECT(entry), "tab_completion_data");
if (!td) return;
g_free(td->fd_title);
td->fd_title = g_strdup(title);
td->fd_folders_only = folders_only;
if (td->fd_button) return;
parent = (td->combo) ? td->combo : td->entry;
hbox = gtk_widget_get_parent(parent);
if (!GTK_IS_BOX(hbox)) return;
td->fd_button = gtk_button_new_with_label("...");
g_signal_connect(G_OBJECT(td->fd_button), "size_allocate",
G_CALLBACK(tab_completion_button_size_allocate), parent);
g_signal_connect(G_OBJECT(td->fd_button), "clicked",
G_CALLBACK(tab_completion_select_pressed), td);
gtk_box_pack_start(GTK_BOX(hbox), td->fd_button, FALSE, FALSE, 0);
gtk_widget_show(td->fd_button);
}
void wxToggleButton::DoApplyWidgetStyle(GtkRcStyle *style)
{
GTKApplyStyle(m_widget, style);
GtkWidget* child = gtk_bin_get_child(GTK_BIN(m_widget));
GTKApplyStyle(child, style);
#ifndef __WXGTK4__
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
// for buttons with images, the path to the label is (at least in 2.12)
// GtkButton -> GtkAlignment -> GtkHBox -> GtkLabel
if ( GTK_IS_ALIGNMENT(child) )
{
GtkWidget* box = gtk_bin_get_child(GTK_BIN(child));
if ( GTK_IS_BOX(box) )
{
wxGtkList list(gtk_container_get_children(GTK_CONTAINER(box)));
for (GList* item = list; item; item = item->next)
{
GTKApplyStyle(GTK_WIDGET(item->data), style);
}
}
}
wxGCC_WARNING_RESTORE()
#endif
}
static GtkWidget *
get_label_from_container (GtkWidget *container)
{
GtkWidget *label;
GList *children, *tmp_list;
if (!GTK_IS_CONTAINER (container))
return NULL;
children = gtk_container_get_children (GTK_CONTAINER (container));
label = NULL;
for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next)
{
if (GTK_IS_LABEL (tmp_list->data))
{
label = tmp_list->data;
break;
}
else if (GTK_IS_CELL_VIEW (tmp_list->data))
{
label = tmp_list->data;
break;
}
else if (GTK_IS_BOX (tmp_list->data))
{
label = get_label_from_container (GTK_WIDGET (tmp_list->data));
if (label)
break;
}
}
g_list_free (children);
return label;
}
void dt_ui_container_add_widget(dt_ui_t *ui, const dt_ui_container_t c, GtkWidget *w)
{
// if(!GTK_IS_BOX(ui->containers[c])) return;
g_return_if_fail(GTK_IS_BOX(ui->containers[c]));
switch(c)
{
/* if box is right lets pack at end for nicer alignment */
case DT_UI_CONTAINER_PANEL_TOP_RIGHT:
case DT_UI_CONTAINER_PANEL_CENTER_TOP_RIGHT:
case DT_UI_CONTAINER_PANEL_CENTER_BOTTOM_RIGHT:
gtk_box_pack_end(GTK_BOX(ui->containers[c]),w,FALSE,FALSE,2);
break;
/* if box is center we want it to fill as much as it can */
case DT_UI_CONTAINER_PANEL_TOP_CENTER:
case DT_UI_CONTAINER_PANEL_CENTER_TOP_CENTER:
case DT_UI_CONTAINER_PANEL_CENTER_BOTTOM_CENTER:
case DT_UI_CONTAINER_PANEL_BOTTOM:
gtk_box_pack_start(GTK_BOX(ui->containers[c]),w,TRUE,TRUE,2);
break;
default:
{
gtk_box_pack_start(GTK_BOX(ui->containers[c]),w,FALSE,FALSE,2);
} break;
}
gtk_widget_show_all(w);
}
static GtkWidget*
get_label_from_container (GtkWidget *container)
{
GtkWidget *label;
GList *children, *tmp_list;
if (!GTK_IS_CONTAINER (container))
return NULL;
children = gtk_container_get_children (GTK_CONTAINER (container));
label = NULL;
for (tmp_list = children; tmp_list != NULL; tmp_list = tmp_list->next)
{
if (GTK_IS_LABEL (tmp_list->data))
{
label = tmp_list->data;
break;
}
/*
* Get label from menu item in desktop background preferences
* option menu. See bug #144084.
*/
else if (GTK_IS_BOX (tmp_list->data))
{
label = get_label_from_container (GTK_WIDGET (tmp_list->data));
if (label)
break;
}
}
g_list_free (children);
return label;
}
void
glade_gtk_box_remove_child (GladeWidgetAdaptor * adaptor,
GObject * object, GObject * child)
{
GladeWidget *gbox;
gint size;
gchar *special_child_type;
g_return_if_fail (GTK_IS_BOX (object));
g_return_if_fail (GTK_IS_WIDGET (child));
gbox = glade_widget_get_from_gobject (object);
special_child_type = g_object_get_data (child, "special-child-type");
if (special_child_type && !strcmp (special_child_type, "center"))
{
GtkWidget *w;
w = glade_placeholder_new ();
g_object_set_data (G_OBJECT (w), "special-child-type", "center");
gtk_box_set_center_widget (GTK_BOX (object), w);
return;
}
gtk_container_remove (GTK_CONTAINER (object), GTK_WIDGET (child));
if (glade_widget_superuser () == FALSE)
{
glade_widget_property_get (gbox, "size", &size);
glade_widget_property_set (gbox, "size", size);
}
fix_response_id_on_child (gbox, child, FALSE);
}
/* consumes reference on icon */
static void _lxpanel_button_set_icon(GtkWidget* btn, FmIcon* icon, gint size)
{
/* Locate the image within the button. */
GtkWidget * child = gtk_bin_get_child(GTK_BIN(btn));
GtkWidget * img = NULL;
if (GTK_IS_IMAGE(child))
img = child;
else if (GTK_IS_BOX(child))
{
GList * children = gtk_container_get_children(GTK_CONTAINER(child));
img = GTK_WIDGET(GTK_IMAGE(children->data));
g_list_free(children);
}
if (img != NULL)
{
ImgData * data = (ImgData *) g_object_get_qdata(G_OBJECT(img), img_data_id);
if (icon != data->icon || size != data->size) /* something was changed */
{
g_object_unref(data->icon);
data->icon = icon;
data->size = size;
_gtk_image_set_from_file_scaled(img, data);
}
else
g_object_unref(icon);
}
else
g_object_unref(icon);
}
static void
glade_gtk_box_set_size (GObject * object, const GValue * value)
{
GtkBox *box;
GList *child, *children;
guint new_size, old_size, i;
box = GTK_BOX (object);
g_return_if_fail (GTK_IS_BOX (box));
if (glade_util_object_is_loading (object))
return;
children = gtk_container_get_children (GTK_CONTAINER (box));
children = g_list_remove (children, gtk_box_get_center_widget (GTK_BOX (box)));
old_size = g_list_length (children);
new_size = g_value_get_int (value);
if (old_size == new_size)
{
g_list_free (children);
return;
}
/* Ensure placeholders first...
*/
for (i = 0; i < new_size; i++)
{
if (g_list_length (children) < (i + 1))
{
GtkWidget *placeholder = glade_placeholder_new ();
gint blank = glade_gtk_box_get_first_blank (box);
gtk_container_add (GTK_CONTAINER (box), placeholder);
gtk_box_reorder_child (box, placeholder, blank);
}
}
/* The box has shrunk. Remove the widgets that are on those slots */
for (child = g_list_last (children);
child && old_size > new_size; child = g_list_previous (child))
{
GtkWidget *child_widget = child->data;
/* Refuse to remove any widgets that are either GladeWidget objects
* or internal to the hierarchic entity (may be a composite widget,
* not all internal widgets have GladeWidgets).
*/
if (glade_widget_get_from_gobject (child_widget) ||
GLADE_IS_PLACEHOLDER (child_widget) == FALSE)
continue;
gtk_container_remove (GTK_CONTAINER (box), child_widget);
old_size--;
}
g_list_free (children);
}
void
dialog_about (WBCGtk *wbcg)
{
GtkWidget *w, *c;
GList *children;
AboutState *state;
if (gnumeric_dialog_raise_if_exists (wbcg, ABOUT_KEY))
return;
state = g_new0 (AboutState, 1);
w = g_object_new (GTK_TYPE_ABOUT_DIALOG,
"title", _("About Gnumeric"),
"version", GNM_VERSION_FULL,
"website", "http://www.gnumeric.org/",
"website-label", _("Visit the Gnumeric website"),
"logo-icon-name", "gnumeric",
"copyright", _("Copyright \xc2\xa9 1998-2014"),
"comments", _("Free, Fast, Accurate - Pick Any Three!"),
NULL);
state->dialog = w;
g_signal_connect (w, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect_swapped (w, "destroy",
G_CALLBACK (free_state), state);
c = gtk_dialog_get_content_area (GTK_DIALOG (w));
children = gtk_container_get_children (GTK_CONTAINER (c));
if (children && GTK_IS_BOX (children->data)) {
GtkWidget *vbox = children->data;
int height;
PangoLayout *layout;
state->anim_area = gtk_drawing_area_new ();
layout = gtk_widget_create_pango_layout (state->anim_area, NULL);
pango_layout_get_pixel_size (layout, NULL, &height);
gtk_widget_set_size_request (state->anim_area, -1, 4 * height);
g_object_unref (layout);
g_signal_connect (state->anim_area, "draw",
G_CALLBACK (about_dialog_anim_draw),
state);
gtk_box_pack_end (GTK_BOX (vbox), state->anim_area, TRUE, TRUE, 0);
create_animation (state);
state->timer = g_timeout_add (TIME_SLICE, about_dialog_timer, state);
}
g_list_free (children);
gnumeric_keyed_dialog (wbcg, GTK_WINDOW (w), ABOUT_KEY);
gtk_widget_show_all (w);
}
static void add_child(GtkWidget *parent, GtkWidget *child)
{
if(GTK_IS_BOX(parent)) {
gtk_box_pack_start(GTK_BOX(parent), child, TRUE, TRUE, 3);
} else if(GTK_CONTAINER(parent)) {
gtk_container_add(GTK_CONTAINER(parent), child);
} else {
fprintf(stderr, "failed to add child\n");
}
}
void
prop_dialog_add_raw_with_flags(PropDialog *dialog, GtkWidget *widget,
gboolean expand, gboolean fill)
{
g_return_if_fail(GTK_IS_BOX(dialog->lastcont));
dialog->curtable = NULL;
if (!widget) return;
gtk_box_pack_start(GTK_BOX(dialog->lastcont),widget, expand, fill, 0);
}
void CalendarDatePrivate::setParent(GtkWidget* parent) {
if (NULL == parent || !GTK_IS_CONTAINER(parent) || NULL == m_actor) {
return;
}
if (GTK_IS_BOX(parent)) {
gtk_box_pack_start(GTK_BOX(parent), m_actor, TRUE, TRUE, 0);
} else {
gtk_container_add(GTK_CONTAINER(parent), m_actor);
}
}
static void
do_align_left_widget (GtkWidget *widget, GtkSizeGroup **size_group)
{
if (*size_group) {
if (!GTK_IS_BOX (widget)) {
gtk_size_group_add_widget (*size_group, widget);
*size_group = NULL;
}
else
do_align_left_widgets (widget, *size_group);
}
}
void
gimp_toolbox_dnd_init (GimpToolbox *toolbox,
GtkWidget *vbox)
{
GimpContext *context = NULL;
g_return_if_fail (GIMP_IS_TOOLBOX (toolbox));
g_return_if_fail (GTK_IS_BOX (vbox));
context = gimp_toolbox_get_context (toolbox);
/* Before caling any dnd helper functions, setup the drag
* destination manually since we want to handle all drag events
* manually, otherwise we would not be able to give the drag handler
* a chance to handle drag events
*/
gtk_drag_dest_set (vbox,
0, NULL, 0,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gimp_dnd_viewable_dest_add (vbox,
GIMP_TYPE_LAYER,
gimp_toolbox_drop_drawable,
context);
gimp_dnd_viewable_dest_add (vbox,
GIMP_TYPE_LAYER_MASK,
gimp_toolbox_drop_drawable,
context);
gimp_dnd_viewable_dest_add (vbox,
GIMP_TYPE_CHANNEL,
gimp_toolbox_drop_drawable,
context);
gimp_dnd_viewable_dest_add (vbox,
GIMP_TYPE_TOOL_INFO,
gimp_toolbox_drop_tool,
context);
gimp_dnd_viewable_dest_add (vbox,
GIMP_TYPE_BUFFER,
gimp_toolbox_drop_buffer,
context);
gimp_dnd_component_dest_add (vbox,
gimp_toolbox_drop_component,
context);
gimp_dnd_uri_list_dest_add (vbox,
gimp_toolbox_drop_uri_list,
context);
gimp_dnd_pixbuf_dest_add (vbox,
gimp_toolbox_drop_pixbuf,
context);
}
void
gimp_editor_set_box_style (GimpEditor *editor,
GtkBox *box)
{
GtkIconSize button_icon_size;
gint button_spacing;
GtkReliefStyle button_relief;
GList *children;
GList *list;
g_return_if_fail (GIMP_IS_EDITOR (editor));
g_return_if_fail (GTK_IS_BOX (box));
gtk_widget_style_get (GTK_WIDGET (editor),
"button-icon-size", &button_icon_size,
"button-spacing", &button_spacing,
"button-relief", &button_relief,
NULL);
gtk_box_set_spacing (box, button_spacing);
children = gtk_container_get_children (GTK_CONTAINER (box));
for (list = children; list; list = g_list_next (list))
{
if (GTK_IS_BUTTON (list->data))
{
GtkWidget *child;
gtk_button_set_relief (GTK_BUTTON (list->data), button_relief);
child = gtk_bin_get_child (GTK_BIN (list->data));
if (GTK_IS_IMAGE (child))
{
GtkIconSize old_size;
gchar *stock_id;
gtk_image_get_stock (GTK_IMAGE (child), &stock_id, &old_size);
if (button_icon_size != old_size)
gtk_image_set_from_stock (GTK_IMAGE (child),
stock_id, button_icon_size);
}
}
}
g_list_free (children);
}
/**
* gel_ui_container_replace_children:
* @container: A #GtkContainer
* @widget: (transfer full): A #GtkWidget
*
* Removes all children from @container using gel_ui_container_clear() and
* then packs @widget into @container
*/
void
gel_ui_container_replace_children(GtkContainer *container, GtkWidget *widget)
{
g_return_if_fail(GTK_IS_CONTAINER(container));
g_return_if_fail(GTK_IS_WIDGET(widget));
gtk_container_foreach(container, (GtkCallback) gtk_widget_destroy, NULL);
if (GTK_IS_BOX(container))
gtk_box_pack_start(GTK_BOX(container), widget, TRUE, TRUE, 0);
else if (GTK_IS_GRID(container))
{
gtk_grid_attach(GTK_GRID(container), widget, 0, 0, 1, 1);
g_object_set((GObject *) widget, "hexpand", TRUE, "vexpand", TRUE, NULL);
}
}
static void
gtk_tool_button_update_icon_spacing (GtkToolButton *button)
{
GtkWidget *box;
guint spacing;
box = GTK_BIN (button->priv->button)->child;
if (GTK_IS_BOX (box))
{
gtk_widget_style_get (GTK_WIDGET (button),
"icon-spacing", &spacing,
NULL);
gtk_box_set_spacing (GTK_BOX (box), spacing);
}
}
static void
find_entries_and_set_sensitive (GtkWidget * parent, gboolean sensitive)
{
GList *list, *iter;
list = gtk_container_get_children (GTK_CONTAINER (parent));
for (iter = list; iter; iter = iter->next) {
if (GTK_IS_ENTRY (iter->data)) {
gtk_widget_set_sensitive (GTK_WIDGET (iter->data), sensitive);
} else if (GTK_IS_BOX (iter->data)) {
find_entries_and_set_sensitive (GTK_WIDGET (iter->data), sensitive);
}
}
}
void
gimp_enum_radio_frame_add (GtkFrame *frame,
GtkWidget *widget,
gint enum_value,
gboolean below)
{
GtkWidget *box;
g_return_if_fail (GTK_IS_FRAME (frame));
g_return_if_fail (GTK_IS_WIDGET (widget));
box = gtk_bin_get_child (GTK_BIN (frame));
g_return_if_fail (GTK_IS_BOX (box));
gimp_enum_radio_box_add (GTK_BOX (box), widget, enum_value, below);
}
static void
brasero_file_chooser_find_pane (GtkWidget *child,
gpointer footer)
{
if (GTK_IS_PANED (child)) {
GList *children_vbox;
GList *iter_vbox;
GtkWidget *vbox;
vbox = gtk_paned_get_child2 (GTK_PANED (child));
children_vbox = gtk_container_get_children (GTK_CONTAINER (vbox));
for (iter_vbox = children_vbox; iter_vbox; iter_vbox = iter_vbox->next) {
if (GTK_IS_BOX (iter_vbox->data) &&
gtk_orientable_get_orientation (GTK_ORIENTABLE (iter_vbox->data)) == GTK_ORIENTATION_HORIZONTAL) {
GtkPackType packing;
gtk_box_query_child_packing (GTK_BOX (vbox),
GTK_WIDGET (iter_vbox->data),
NULL,
NULL,
NULL,
&packing);
if (packing == GTK_PACK_START) {
GtkRequisition total_request, footer_request;
gtk_widget_get_preferred_size (GTK_WIDGET (vbox),
&total_request, NULL);
gtk_widget_get_preferred_size (GTK_WIDGET (iter_vbox->data),
&footer_request, NULL);
*((gint *) footer) = total_request.height - footer_request.height;
break;
}
}
}
g_list_free (children_vbox);
}
else if (GTK_IS_CONTAINER (child)) {
gtk_container_foreach (GTK_CONTAINER (child),
brasero_file_chooser_find_pane,
footer);
}
}
static void
he_check_button_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
guint horizontal_spacing, vertical_spacing, image_spacing;
HeCheckButtonPrivate *priv = HE_CHECK_BUTTON_GET_PRIVATE (widget);
if (GTK_WIDGET_CLASS (he_check_button_parent_class)->style_set)
GTK_WIDGET_CLASS (he_check_button_parent_class)->style_set (widget, previous_style);
/* Prevent infinite recursion when calling set_logical_font() and
* set_logical_color() */
if (priv->setting_style)
return;
/* Get horizontal-spacing style property from ourself */
gtk_widget_style_get (widget, "horizontal-spacing", &horizontal_spacing, NULL);
/* Get vertical-spacing style property of HildonButton from theme */
GtkStyle *style = gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
"*.*Button-finger", NULL, HILDON_TYPE_BUTTON);
vertical_spacing = get_style_property_long (style, HILDON_TYPE_BUTTON, "vertical-spacing");
/* Get image-spacing style property of HildonCheckButton from theme */
style = gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
NULL, "*.HildonCheckButton", HILDON_TYPE_CHECK_BUTTON);
image_spacing = get_style_property_long (style, GTK_TYPE_BUTTON, "image-spacing");
/* Setting values we got from above */
if (GTK_IS_HBOX (priv->label_box)) {
gtk_box_set_spacing (GTK_BOX (priv->label_box), horizontal_spacing);
} else {
gtk_box_set_spacing (GTK_BOX (priv->label_box), vertical_spacing);
}
if (GTK_IS_BOX (priv->hbox)) {
gtk_box_set_spacing (priv->hbox, image_spacing);
}
set_logical_font (widget);
set_logical_color (widget);
}
void
go_gtk_widget_replace (GtkWidget *victim, GtkWidget *replacement)
{
GtkContainer *parent = GTK_CONTAINER (gtk_widget_get_parent (victim));
if (GTK_IS_GRID (parent)) {
int col, row, width, height;
gtk_container_child_get (parent,
victim,
"left-attach", &col,
"top-attach", &row,
"width", &width,
"height", &height,
NULL);
gtk_container_remove (parent, victim);
gtk_grid_attach (GTK_GRID (parent), replacement,
col, row, width, height);
} else if (GTK_IS_BOX (parent)) {
GtkBox *box = GTK_BOX (parent);
gboolean expand, fill;
guint padding;
GtkPackType pack_type;
int pos;
gtk_box_query_child_packing (box, victim,
&expand, &fill,
&padding, &pack_type);
gtk_container_child_get (parent, victim,
"position", &pos,
NULL);
gtk_container_remove (parent, victim);
gtk_container_add (parent, replacement);
gtk_box_set_child_packing (box, replacement,
expand, fill,
padding, pack_type);
gtk_box_reorder_child (box, replacement, pos);
} else {
g_error ("Unsupported container: %s",
g_type_name_from_instance ((gpointer)parent));
}
}
void wxButton::DoApplyWidgetStyle(GtkRcStyle *style)
{
gtk_widget_modify_style(m_widget, style);
GtkWidget *child = GTK_BIN(m_widget)->child;
gtk_widget_modify_style(child, style);
// for buttons with images, the path to the label is (at least in 2.12)
// GtkButton -> GtkAlignment -> GtkHBox -> GtkLabel
if ( GTK_IS_ALIGNMENT(child) )
{
GtkWidget *box = GTK_BIN(child)->child;
if ( GTK_IS_BOX(box) )
{
for (GList* item = GTK_BOX(box)->children; item; item = item->next)
{
GtkBoxChild* boxChild = static_cast<GtkBoxChild*>(item->data);
gtk_widget_modify_style(boxChild->widget, style);
}
}
}
}
MidoratorEntry* midorator_entry_new(GtkWidget *parent) {
GtkWidget *e = g_object_new(MIDORATOR_TYPE_ENTRY, NULL);
gtk_entry_set_has_frame(GTK_ENTRY(e), false);
if (parent) {
gtk_widget_modify_base(e, GTK_STATE_NORMAL, &parent->style->bg[0]);
gtk_widget_modify_base(e, GTK_STATE_ACTIVE, &parent->style->bg[0]);
gtk_widget_modify_bg(e, GTK_STATE_NORMAL, &parent->style->bg[0]);
gtk_widget_modify_bg(e, GTK_STATE_ACTIVE, &parent->style->bg[0]);
}
if (GTK_IS_BOX(parent)) {
gtk_box_pack_start(GTK_BOX(parent), e, true, true, 0);
gtk_widget_show(e);
gtk_widget_grab_focus(e);
gtk_box_reorder_child(GTK_BOX(parent), e, 0);
} else if (GTK_IS_CONTAINER(parent)) {
gtk_container_add(GTK_CONTAINER(parent), e);
gtk_widget_show(e);
}
return MIDORATOR_ENTRY(e);
//return (MidoratorEntry*)(e);
}
void wxToggleButton::DoApplyWidgetStyle(GtkRcStyle *style)
{
GTKApplyStyle(m_widget, style);
GtkWidget* child = gtk_bin_get_child(GTK_BIN(m_widget));
GTKApplyStyle(child, style);
// for buttons with images, the path to the label is (at least in 2.12)
// GtkButton -> GtkAlignment -> GtkHBox -> GtkLabel
if ( GTK_IS_ALIGNMENT(child) )
{
GtkWidget* box = gtk_bin_get_child(GTK_BIN(child));
if ( GTK_IS_BOX(box) )
{
wxGtkList list(gtk_container_get_children(GTK_CONTAINER(box)));
for (GList* item = list; item; item = item->next)
{
GTKApplyStyle(GTK_WIDGET(item->data), style);
}
}
}
}
static void
gog_trend_line_populate_editor (GogObject *gobj,
GOEditor *editor,
GogDataAllocator *dalloc,
GOCmdContext *cc)
{
GtkWidget *w, *box;
GogTrendLine *line = GOG_TREND_LINE (gobj);
box = go_editor_get_page (editor, _("Properties"));
if (!box)
box = go_editor_get_page (editor, _("Details"));
if (!box) {
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (box), 12);
gtk_widget_show_all (box);
go_editor_add_page (editor, box, _("Legend"));
}
w = gtk_check_button_new_with_mnemonic (_("_Show in Legend"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w),
gog_trend_line_has_legend (line));
g_signal_connect (G_OBJECT (w),
"toggled",
G_CALLBACK (cb_show_in_legend), gobj);
if (GTK_IS_BOX (box))
gtk_box_pack_start (GTK_BOX (box), w, FALSE, FALSE, 0);
else if (GTK_IS_GRID (box)) {
GtkGrid *grid = GTK_GRID (box);
gtk_grid_insert_row (grid, 1);
gtk_grid_attach (grid, w, 0, 1, 2, 1);
} else if (GTK_IS_CONTAINER (box))
gtk_container_add (GTK_CONTAINER (box), w);
else
g_warning ("Unsupported container");
gtk_widget_show (w);
(GOG_OBJECT_CLASS (trend_line_parent_klass)->populate_editor) (gobj, editor, dalloc, cc);
}
/**
* ea_calendar_helpers_get_view_widget_from:
* @canvas_item: the canvas item for a event or a jump button
*
* Get the cal view widget contains the canvas_item.
*
* Returns: the cal view widget if exists
**/
ECalendarView *
ea_calendar_helpers_get_cal_view_from (GnomeCanvasItem *canvas_item)
{
GnomeCanvas *canvas;
GtkWidget *view_widget = NULL;
g_return_val_if_fail (canvas_item, NULL);
g_return_val_if_fail ((E_IS_TEXT (canvas_item)) ||
(GNOME_IS_CANVAS_ITEM (canvas_item)), NULL);
/* canvas_item is the e_text for the event */
/* canvas_item->canvas is the ECanvas for day view */
/* parent of canvas_item->canvas is the EDayView or EWeekView widget */
canvas = canvas_item->canvas;
view_widget = gtk_widget_get_parent (GTK_WIDGET (canvas));
if (view_widget && GTK_IS_BOX (view_widget))
view_widget = gtk_widget_get_parent (view_widget);
if (!view_widget || !E_IS_CALENDAR_VIEW (view_widget))
return NULL;
return E_CALENDAR_VIEW (view_widget);
}
static void deja_dup_config_photo_dialog_create_widgets (DejaDupConfigPhotoDialog* self) {
const gchar* _tmp0_ = NULL;
GtkLabel* _tmp1_;
GtkLabel* _tmp2_;
GtkLabel* label;
GtkSwitch* _tmp3_;
GtkSwitch* _tmp4_;
const gchar* _tmp5_ = NULL;
GtkLabel* _tmp6_;
GtkLabel* _tmp7_;
GtkLabel* description;
GtkBox* _tmp8_;
GtkBox* _tmp9_;
GtkBox* hbox;
GtkSwitch* _tmp10_;
GtkBox* _tmp11_ = NULL;
GtkBox* _tmp12_;
GtkBox* content;
DejaDupSimpleSettings* _tmp13_ = NULL;
DejaDupSimpleSettings* settings;
gboolean _tmp14_ = FALSE;
gboolean value;
GtkSwitch* _tmp15_;
GtkSwitch* _tmp16_;
g_return_if_fail (self != NULL);
_tmp0_ = _ ("Photo Stream");
_tmp1_ = (GtkLabel*) gtk_label_new_with_mnemonic (_tmp0_);
_tmp2_ = g_object_ref_sink (_tmp1_);
label = _tmp2_;
_tmp3_ = (GtkSwitch*) gtk_switch_new ();
_tmp4_ = g_object_ref_sink (_tmp3_);
_g_object_unref0 (self->priv->button);
self->priv->button = _tmp4_;
_tmp5_ = _ ("Automatically upload photos and send them to all of you devices.");
_tmp6_ = (GtkLabel*) gtk_label_new_with_mnemonic (_tmp5_);
_tmp7_ = g_object_ref_sink (_tmp6_);
description = _tmp7_;
g_object_set ((GObject*) description, "use-markup", TRUE, "xalign", 0.5f, NULL);
_tmp8_ = (GtkBox*) gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20);
_tmp9_ = g_object_ref_sink (_tmp8_);
hbox = _tmp9_;
gtk_box_pack_start (hbox, (GtkWidget*) label, FALSE, TRUE, (guint) 0);
_tmp10_ = self->priv->button;
gtk_box_pack_end (hbox, (GtkWidget*) _tmp10_, FALSE, FALSE, (guint) 0);
_tmp11_ = gtk_dialog_get_content_area ((GtkDialog*) self);
_tmp12_ = _g_object_ref0 (GTK_IS_BOX (_tmp11_) ? ((GtkBox*) _tmp11_) : NULL);
content = _tmp12_;
gtk_box_pack_start (content, (GtkWidget*) hbox, FALSE, TRUE, (guint) 0);
gtk_box_set_spacing (content, 10);
_tmp13_ = deja_dup_get_settings (DEJA_DUP_APPS_ROOT ".photo-stream");
settings = _tmp13_;
_tmp14_ = g_settings_get_boolean ((GSettings*) settings, DEJA_DUP_BACKUP_KEY);
value = _tmp14_;
_tmp15_ = self->priv->button;
gtk_switch_set_active (_tmp15_, value);
_tmp16_ = self->priv->button;
g_signal_connect_object ((GObject*) _tmp16_, "notify::active", (GCallback) _deja_dup_config_photo_dialog_handle_toggled_g_object_notify, self, 0);
gtk_dialog_add_button ((GtkDialog*) self, GTK_STOCK_CLOSE, (gint) GTK_RESPONSE_CLOSE);
_g_object_unref0 (settings);
_g_object_unref0 (content);
_g_object_unref0 (hbox);
_g_object_unref0 (description);
_g_object_unref0 (label);
}
static AtkRelationSet *
gtk_widget_accessible_ref_relation_set (AtkObject *obj)
{
GtkWidget *widget;
AtkRelationSet *relation_set;
GtkWidget *label;
AtkObject *array[1];
AtkRelation* relation;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (widget == NULL)
return NULL;
relation_set = ATK_OBJECT_CLASS (_gtk_widget_accessible_parent_class)->ref_relation_set (obj);
if (GTK_IS_BOX (widget))
return relation_set;
if (!atk_relation_set_contains (relation_set, ATK_RELATION_LABELLED_BY))
{
label = find_label (widget);
if (label == NULL)
{
if (GTK_IS_BUTTON (widget))
/*
* Handle the case where GnomeIconEntry is the mnemonic widget.
* The GtkButton which is a grandchild of the GnomeIconEntry
* should really be the mnemonic widget. See bug #133967.
*/
{
GtkWidget *temp_widget;
temp_widget = gtk_widget_get_parent (widget);
if (GTK_IS_ALIGNMENT (temp_widget))
{
temp_widget = gtk_widget_get_parent (temp_widget);
if (GTK_IS_BOX (temp_widget))
{
label = find_label (temp_widget);
if (!label)
label = find_label (gtk_widget_get_parent (temp_widget));
}
}
}
else if (GTK_IS_COMBO_BOX (widget))
/*
* Handle the case when GtkFileChooserButton is the mnemonic
* widget. The GtkComboBox which is a child of the
* GtkFileChooserButton should be the mnemonic widget.
* See bug #359843.
*/
{
GtkWidget *temp_widget;
temp_widget = gtk_widget_get_parent (widget);
if (GTK_IS_BOX (temp_widget))
{
label = find_label (temp_widget);
}
}
}
if (label)
{
array[0] = gtk_widget_get_accessible (label);
relation = atk_relation_new (array, 1, ATK_RELATION_LABELLED_BY);
atk_relation_set_add (relation_set, relation);
g_object_unref (relation);
}
}
return relation_set;
}
