static void
eel_wrap_table_remove (GtkContainer *container,
GtkWidget *child)
{
EelWrapTable *wrap_table;
gboolean child_was_visible;
g_assert (EEL_IS_WRAP_TABLE (container));
g_assert (GTK_IS_WIDGET (child));
wrap_table = EEL_WRAP_TABLE (container);;
child_was_visible = gtk_widget_get_visible (child);
gtk_widget_unparent (child);
wrap_table->details->children = g_list_remove (wrap_table->details->children, child);
if (child_was_visible)
{
gtk_widget_queue_resize (GTK_WIDGET (container));
}
if (wrap_table->details->is_scrolled)
{
g_signal_handlers_disconnect_by_func (
child,
G_CALLBACK (wrap_table_child_focus_in),
wrap_table);
}
}
eel_wrap_table_expose_event (GtkWidget *widget,
GdkEventExpose *event)
#endif
{
EelWrapTable *wrap_table;
GList *iterator;
g_assert (EEL_IS_WRAP_TABLE (widget));
g_assert (gtk_widget_get_realized (widget));
#if !GTK_CHECK_VERSION (3, 0, 0)
g_assert (event != NULL);
#endif
wrap_table = EEL_WRAP_TABLE (widget);
for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
{
g_assert (GTK_IS_WIDGET (iterator->data));
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_container_propagate_draw (GTK_CONTAINER (widget),
GTK_WIDGET (iterator->data),
cr);
#else
gtk_container_propagate_expose (GTK_CONTAINER (widget),
GTK_WIDGET (iterator->data),
event);
#endif
}
return FALSE;
}
static int
eel_wrap_table_draw (GtkWidget *widget,
cairo_t *cr)
{
EelWrapTable *wrap_table;
GList *iterator;
g_assert (EEL_IS_WRAP_TABLE (widget));
g_assert (gtk_widget_get_realized (widget));
wrap_table = EEL_WRAP_TABLE (widget);
for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
{
g_assert (GTK_IS_WIDGET (iterator->data));
gtk_container_propagate_draw (GTK_CONTAINER (widget),
GTK_WIDGET (iterator->data),
cr);
}
/*Redraw the table once and only once to ensure it is displayed */
if (wrap_table->details->drawn == FALSE){
gtk_widget_queue_allocate (GTK_WIDGET(widget));
wrap_table->details->drawn = TRUE;
}
return FALSE;
}
static void
eel_wrap_table_finalize (GObject *object)
{
EelWrapTable *wrap_table;
wrap_table = EEL_WRAP_TABLE (object);
g_list_free (wrap_table->details->children);
G_OBJECT_CLASS (eel_wrap_table_parent_class)->finalize (object);
}
/**
* eel_wrap_table_new:
*
*/
GtkWidget*
eel_wrap_table_new (gboolean homogeneous)
{
EelWrapTable *wrap_table;
wrap_table = EEL_WRAP_TABLE (gtk_widget_new (eel_wrap_table_get_type (), NULL));
eel_wrap_table_set_homogeneous (wrap_table, homogeneous);
return GTK_WIDGET (wrap_table);
}
static void
eel_wrap_table_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
EelWrapTable *wrap_table;
g_assert (EEL_IS_WRAP_TABLE (widget));
g_assert (allocation != NULL);
wrap_table = EEL_WRAP_TABLE (widget);
gtk_widget_set_allocation (widget, allocation);
wrap_table_layout (wrap_table);
}
/* GtkWidgetClass methods */
static void
eel_wrap_table_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
EelWrapTable *wrap_table;
EelDimensions content_dimensions;
g_assert (EEL_IS_WRAP_TABLE (widget));
g_assert (requisition != NULL);
wrap_table = EEL_WRAP_TABLE (widget);
content_dimensions = wrap_table_get_content_dimensions (wrap_table);
/* The -1 tells Satan to use as much space as is available */
requisition->width = -1;
requisition->height = content_dimensions.height + gtk_container_get_border_width (GTK_CONTAINER (widget)) * 2;
}
/* GtkContainerClass methods */
static void
eel_wrap_table_add (GtkContainer *container,
GtkWidget *child)
{
EelWrapTable *wrap_table;
GtkWidget *widget;
g_assert (container != NULL);
g_assert (EEL_IS_WRAP_TABLE (container));
g_assert (GTK_IS_WIDGET (child));
widget = GTK_WIDGET (container);
wrap_table = EEL_WRAP_TABLE (container);
gtk_widget_set_parent (child, GTK_WIDGET (container));
wrap_table->details->children = g_list_append (wrap_table->details->children, child);
if (gtk_widget_get_realized (widget))
{
gtk_widget_realize (child);
}
if (gtk_widget_get_visible (widget) && gtk_widget_get_visible (child))
{
if (gtk_widget_get_mapped (widget))
{
gtk_widget_map (child);
}
gtk_widget_queue_resize (child);
}
if (wrap_table->details->is_scrolled)
{
g_signal_connect (child, "focus_in_event",
G_CALLBACK (wrap_table_child_focus_in),
wrap_table);
}
}
static void
eel_wrap_table_forall (GtkContainer *container,
gboolean include_internals,
GtkCallback callback,
gpointer callback_data)
{
EelWrapTable *wrap_table;
GList *node;
GList *next;
g_assert (EEL_IS_WRAP_TABLE (container));
g_assert (callback != NULL);
wrap_table = EEL_WRAP_TABLE (container);;
for (node = wrap_table->details->children; node != NULL; node = next)
{
g_assert (GTK_IS_WIDGET (node->data));
next = node->next;
(* callback) (GTK_WIDGET (node->data), callback_data);
}
}
static void
eel_wrap_table_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
EelWrapTable *wrap_table;
g_assert (EEL_IS_WRAP_TABLE (object));
wrap_table = EEL_WRAP_TABLE (object);
switch (property_id)
{
case PROP_X_SPACING:
eel_wrap_table_set_x_spacing (wrap_table, g_value_get_uint (value));
break;
case PROP_Y_SPACING:
eel_wrap_table_set_y_spacing (wrap_table, g_value_get_uint (value));
break;
case PROP_X_JUSTIFICATION:
eel_wrap_table_set_x_justification (wrap_table, g_value_get_enum (value));
break;
case PROP_Y_JUSTIFICATION:
eel_wrap_table_set_y_justification (wrap_table, g_value_get_enum (value));
break;
case PROP_HOMOGENEOUS:
eel_wrap_table_set_homogeneous (wrap_table, g_value_get_boolean (value));
break;
default:
g_assert_not_reached ();
}
}
static int
eel_wrap_table_expose_event (GtkWidget *widget,
GdkEventExpose *event)
{
EelWrapTable *wrap_table;
GList *iterator;
g_assert (EEL_IS_WRAP_TABLE (widget));
g_assert (gtk_widget_get_realized (widget));
g_assert (event != NULL);
wrap_table = EEL_WRAP_TABLE (widget);
for (iterator = wrap_table->details->children; iterator; iterator = iterator->next)
{
g_assert (GTK_IS_WIDGET (iterator->data));
gtk_container_propagate_expose (GTK_CONTAINER (widget),
GTK_WIDGET (iterator->data),
event);
}
return FALSE;
}
GtkWidget *
eel_scrolled_wrap_table_new (gboolean homogeneous,
GtkShadowType shadow_type,
GtkWidget **wrap_table_out)
{
GtkWidget *scrolled_window;
GtkWidget *wrap_table;
GtkWidget *viewport;
g_return_val_if_fail (wrap_table_out != NULL, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_overlay_scrolling (GTK_SCROLLED_WINDOW (scrolled_window), FALSE);
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport),
shadow_type);
gtk_container_add (GTK_CONTAINER (scrolled_window),
viewport);
wrap_table = eel_wrap_table_new (homogeneous);
gtk_container_add (GTK_CONTAINER (viewport),
wrap_table);
gtk_widget_show (wrap_table);
gtk_widget_show (viewport);
EEL_WRAP_TABLE (wrap_table)->details->is_scrolled = 1;
*wrap_table_out = wrap_table;
return scrolled_window;
}
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 GtkWidget *
image_table_new_scrolled (void)
{
GtkWidget *scrolled;
GtkWidget *viewport;
GtkWidget *window;
GtkWidget *image_table;
int i;
window = test_window_new ("Image Table Test", 10);
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
/* Scrolled window */
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (window), scrolled);
/* Viewport */
viewport = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_OUT);
gtk_container_add (GTK_CONTAINER (scrolled), viewport);
image_table = eel_image_table_new (FALSE);
if (0) g_signal_connect (image_table,
"size_allocate",
G_CALLBACK (image_table_size_allocate),
window);
eel_wrap_table_set_x_justification (EEL_WRAP_TABLE (image_table),
EEL_JUSTIFICATION_MIDDLE);
eel_wrap_table_set_y_justification (EEL_WRAP_TABLE (image_table),
EEL_JUSTIFICATION_END);
gtk_container_add (GTK_CONTAINER (viewport), image_table);
g_signal_connect (image_table,
"child_enter",
G_CALLBACK (image_table_child_enter_callback),
NULL);
g_signal_connect (image_table,
"child_leave",
G_CALLBACK (image_table_child_leave_callback),
NULL);
g_signal_connect (image_table,
"child_pressed",
G_CALLBACK (image_table_child_pressed_callback),
NULL);
g_signal_connect (image_table,
"child_released",
G_CALLBACK (image_table_child_released_callback),
NULL);
g_signal_connect (image_table,
"child_clicked",
G_CALLBACK (image_table_child_clicked_callback),
NULL);
eel_gtk_widget_set_background_color (viewport, BG_COLOR_SPEC);
for (i = 0; i < 100; i++) {
char *text;
GtkWidget *image;
text = g_strdup_printf ("%s %d",
names[random () % G_N_ELEMENTS (names)],
i);
image = labeled_image_new (text, pixbuf_name);
g_free (text);
gtk_container_add (GTK_CONTAINER (image_table), image);
gtk_widget_show (image);
}
gtk_widget_show (viewport);
gtk_widget_show (scrolled);
gtk_widget_show (image_table);
return window;
}
static GtkWidget *
create_add_emblems_dialog (CajaEmblemSidebar *emblem_sidebar,
GSList *emblems)
{
GtkWidget *dialog, *label, *table, *image;
GtkWidget *first_entry, *entry, *scroller, *hbox;
Emblem *emblem;
GSList *list;
int num_emblems;
first_entry = NULL;
dialog = gtk_dialog_new_with_buttons (_("Add Emblems..."),
NULL,
0,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
GTK_STOCK_HELP,
GTK_RESPONSE_HELP,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
/* FIXME: make a better message */
if (g_slist_length (emblems) > 1)
{
label = gtk_label_new (_("Enter a descriptive name next to each emblem. This name will be used in other places to identify the emblem."));
}
else
{
label = gtk_label_new (_("Enter a descriptive name next to the emblem. This name will be used in other places to identify the emblem."));
}
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
label, FALSE, FALSE, 8);
gtk_widget_show (label);
scroller = eel_scrolled_wrap_table_new (TRUE, GTK_SHADOW_NONE, &table);
eel_wrap_table_set_x_spacing (EEL_WRAP_TABLE (table), 8);
eel_wrap_table_set_y_spacing (EEL_WRAP_TABLE (table), 8);
num_emblems=0;
list = emblems;
while (list != NULL)
{
/* walk through the list of emblems, and create an image
* and entry for each one
*/
emblem = (Emblem *)list->data;
list = list->next;
image = gtk_image_new_from_pixbuf (emblem->pixbuf);
hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
g_signal_connect (entry, "changed",
G_CALLBACK (emblem_name_entry_changed_cb),
emblem);
gtk_box_pack_start (GTK_BOX (hbox), entry, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (table), hbox);
if (num_emblems == 0)
{
first_entry = entry;
}
num_emblems++;
}
gtk_container_set_border_width (GTK_CONTAINER (dialog), 8);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
scroller, TRUE, TRUE, 8);
gtk_widget_show_all (scroller);
gtk_widget_grab_focus (first_entry);
/* we expand the window to hold up to about 4 emblems, but after that
* let the scroller do its thing. Is there a better way to do this?
*/
gtk_window_set_default_size (GTK_WINDOW (dialog), 400,
MIN (120+(60*num_emblems), 350));
g_object_set_data_full (G_OBJECT (dialog), "emblems-to-add",
emblems, (GDestroyNotify)destroy_emblem_list);
return dialog;
}
