/* LIBPIKA - The PIKA Library * Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball * * pikawidgets.c * Copyright (C) 2000 Michael Natterer * * This library is free software: you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 3 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see * . */ #include "config.h" #include #include #include "libpikacolor/pikacolor.h" #include "libpikamath/pikamath.h" #include "libpikabase/pikabase.h" #include "pikawidgets.h" #include "libpika/libpika-intl.h" /** * SECTION: pikawidgets * @title: PikaWidgets * @short_description: A collection of convenient widget constructors, * standard callbacks and helper functions. * * A collection of convenient widget constructors, standard callbacks * and helper functions. **/ /** * pika_int_radio_group_new: (skip) * @in_frame: %TRUE if you want a #GtkFrame around the * radio button group. * @frame_title: (nullable): * The title of the Frame or %NULL if you don't want a * title. * @radio_button_callback: (scope notified): The callback each button's * "toggled" signal will be connected with. * @radio_button_callback_data: (closure radio_button_callback): * The data which will be passed to g_signal_connect(). * @radio_button_callback_destroy: (destroy radio_button_callback_data): * @initial: The @item_data of the initially pressed radio button. * @...: A %NULL-terminated @va_list describing * the radio buttons. * * Convenience function to create a group of radio buttons embedded into * a #GtkFrame or #GtkBox. This function does the same thing as * pika_radio_group_new2(), but it takes integers as @item_data instead of * pointers, since that is a very common case (mapping an enum to a radio * group). * * Returns: (transfer full): A #GtkFrame or #GtkBox (depending on @in_frame). **/ GtkWidget * pika_int_radio_group_new (gboolean in_frame, const gchar *frame_title, GCallback radio_button_callback, gpointer radio_button_callback_data, GDestroyNotify radio_button_callback_destroy, gint initial, /* item_data */ /* specify radio buttons as va_list: * const gchar *label, * gint item_data, * GtkWidget **widget_ptr, */ ...) { GtkWidget *vbox; GtkWidget *button; GSList *group; /* radio button variables */ const gchar *label; gint item_data; gpointer item_ptr; GtkWidget **widget_ptr; va_list args; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); group = NULL; if (radio_button_callback_destroy) g_object_weak_ref (G_OBJECT (vbox), (GWeakNotify) radio_button_callback_destroy, radio_button_callback_data); /* create the radio buttons */ va_start (args, initial); label = va_arg (args, const gchar *); while (label) { item_data = va_arg (args, gint); widget_ptr = va_arg (args, GtkWidget **); item_ptr = GINT_TO_POINTER (item_data); if (label != GINT_TO_POINTER (1)) button = gtk_radio_button_new_with_mnemonic (group, label); else button = gtk_radio_button_new (group); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); if (item_data) { g_object_set_data (G_OBJECT (button), "pika-item-data", item_ptr); /* backward compatibility */ g_object_set_data (G_OBJECT (button), "user_data", item_ptr); } if (widget_ptr) *widget_ptr = button; if (initial == item_data) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); g_signal_connect (button, "toggled", radio_button_callback, radio_button_callback_data); gtk_widget_show (button); label = va_arg (args, const gchar *); } va_end (args); if (in_frame) { GtkWidget *frame; frame = pika_frame_new (frame_title); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); return frame; } return vbox; } /** * pika_int_radio_group_set_active: * @radio_button: Pointer to a #GtkRadioButton. * @item_data: The @item_data of the radio button you want to select. * * Calls gtk_toggle_button_set_active() with the radio button that was created * with a matching @item_data. This function does the same thing as * pika_radio_group_set_active(), but takes integers as @item_data instead * of pointers. **/ void pika_int_radio_group_set_active (GtkRadioButton *radio_button, gint item_data) { GtkWidget *button; GSList *group; g_return_if_fail (GTK_IS_RADIO_BUTTON (radio_button)); for (group = gtk_radio_button_get_group (radio_button); group; group = g_slist_next (group)) { button = GTK_WIDGET (group->data); if (g_object_get_data (G_OBJECT (button), "pika-item-data") == GINT_TO_POINTER (item_data)) { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); return; } } } static void pika_random_seed_update (GtkWidget *widget, gpointer data) { GtkWidget *spinbutton = data; /* Generate a new seed if the "New Seed" button was clicked or * of the "Randomize" toggle is activated */ if (! GTK_IS_TOGGLE_BUTTON (widget) || gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { gtk_spin_button_set_value (GTK_SPIN_BUTTON (spinbutton), (guint) g_random_int ()); } } /** * pika_random_seed_new: * @seed: A pointer to the variable which stores the random seed. * @random_seed: A pointer to a boolean indicating whether seed should be * initialised randomly or not. * * Creates a widget that allows the user to control how the random number * generator is initialized. * * Returns: (transfer full): A #GtkBox containing a #GtkSpinButton for * the seed and a #GtkButton for setting a random seed. **/ GtkWidget * pika_random_seed_new (guint *seed, gboolean *random_seed) { GtkWidget *hbox; GtkWidget *toggle; GtkWidget *spinbutton; GtkAdjustment *adj; GtkWidget *button; g_return_val_if_fail (seed != NULL, NULL); g_return_val_if_fail (random_seed != NULL, NULL); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4); /* If we're being asked to generate a random seed, generate one. */ if (*random_seed) *seed = g_random_int (); adj = gtk_adjustment_new (*seed, 0, (guint32) -1, 1, 10, 0); spinbutton = pika_spin_button_new (adj, 1.0, 0); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); g_signal_connect (adj, "value-changed", G_CALLBACK (pika_uint_adjustment_update), seed); pika_help_set_help_data (spinbutton, _("Use this value for random number generator " "seed - this allows you to repeat a " "given \"random\" operation"), NULL); button = gtk_button_new_with_mnemonic (_("_New Seed")); g_object_set (gtk_bin_get_child (GTK_BIN (button)), "margin-start", 2, "margin-end", 2, NULL); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); /* Send spinbutton as data so that we can change the value in * pika_random_seed_update() */ g_signal_connect (button, "clicked", G_CALLBACK (pika_random_seed_update), spinbutton); pika_help_set_help_data (button, _("Seed random number generator with a generated " "random number"), NULL); toggle = gtk_check_button_new_with_mnemonic (_("_Randomize")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), *random_seed); gtk_box_pack_start (GTK_BOX (hbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (pika_toggle_button_update), random_seed); /* Need to create a new seed when the "Randomize" toggle is activated */ g_signal_connect (toggle, "toggled", G_CALLBACK (pika_random_seed_update), spinbutton); g_object_set_data (G_OBJECT (hbox), "spinbutton", spinbutton); g_object_set_data (G_OBJECT (hbox), "button", button); g_object_set_data (G_OBJECT (hbox), "toggle", toggle); g_object_bind_property (toggle, "active", spinbutton, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); g_object_bind_property (toggle, "active", button, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); return hbox; } typedef struct { PikaChainButton *chainbutton; gboolean chain_constrains_ratio; gdouble orig_x; gdouble orig_y; gdouble last_x; gdouble last_y; } PikaCoordinatesData; static void pika_coordinates_callback (GtkWidget *widget, PikaCoordinatesData *data) { gdouble new_x; gdouble new_y; new_x = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (widget), 0); new_y = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (widget), 1); if (pika_chain_button_get_active (data->chainbutton)) { if (data->chain_constrains_ratio) { if ((data->orig_x != 0) && (data->orig_y != 0)) { g_signal_handlers_block_by_func (widget, pika_coordinates_callback, data); if (ROUND (new_x) != ROUND (data->last_x)) { data->last_x = new_x; new_y = (new_x * data->orig_y) / data->orig_x; pika_size_entry_set_refval (PIKA_SIZE_ENTRY (widget), 1, new_y); data->last_y = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (widget), 1); } else if (ROUND (new_y) != ROUND (data->last_y)) { data->last_y = new_y; new_x = (new_y * data->orig_x) / data->orig_y; pika_size_entry_set_refval (PIKA_SIZE_ENTRY (widget), 0, new_x); data->last_x = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (widget), 0); } g_signal_handlers_unblock_by_func (widget, pika_coordinates_callback, data); } } else { if (new_x != data->last_x) { pika_size_entry_set_refval (PIKA_SIZE_ENTRY (widget), 1, new_x); data->last_y = data->last_x = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (widget), 1); } else if (new_y != data->last_y) { pika_size_entry_set_refval (PIKA_SIZE_ENTRY (widget), 0, new_y); data->last_x = data->last_y = pika_size_entry_get_refval (PIKA_SIZE_ENTRY (widget), 0); } } } else { if (new_x != data->last_x) data->last_x = new_x; if (new_y != data->last_y) data->last_y = new_y; } } static void pika_coordinates_data_free (PikaCoordinatesData *data) { g_slice_free (PikaCoordinatesData, data); } static void pika_coordinates_chainbutton_toggled (PikaChainButton *button, PikaSizeEntry *entry) { if (pika_chain_button_get_active (button)) { PikaCoordinatesData *data; data = g_object_get_data (G_OBJECT (entry), "coordinates-data"); data->orig_x = pika_size_entry_get_refval (entry, 0); data->orig_y = pika_size_entry_get_refval (entry, 1); } } /** * pika_coordinates_new: * @unit: The initial unit of the #PikaUnitMenu. * @unit_format: A printf-like unit-format string as is used with * pika_unit_menu_new(). * @menu_show_pixels: %TRUE if the #PikaUnitMenu should contain an item * for PIKA_UNIT_PIXEL. * @menu_show_percent: %TRUE if the #PikaUnitMenu should contain an item * for PIKA_UNIT_PERCENT. * @spinbutton_width: The horizontal size of the #PikaSizeEntry's * #GtkSpinButton's. * @update_policy: The update policy for the #PikaSizeEntry. * @chainbutton_active: %TRUE if the attached #PikaChainButton should be * active. * @chain_constrains_ratio: %TRUE if the chainbutton should constrain the * fields' aspect ratio. If %FALSE, the values will * be constrained. * @xlabel: The label for the X coordinate. * @x: The initial value of the X coordinate. * @xres: The horizontal resolution in DPI. * @lower_boundary_x: The lower boundary of the X coordinate. * @upper_boundary_x: The upper boundary of the X coordinate. * @xsize_0: The X value which will be treated as 0%. * @xsize_100: The X value which will be treated as 100%. * @ylabel: The label for the Y coordinate. * @y: The initial value of the Y coordinate. * @yres: The vertical resolution in DPI. * @lower_boundary_y: The lower boundary of the Y coordinate. * @upper_boundary_y: The upper boundary of the Y coordinate. * @ysize_0: The Y value which will be treated as 0%. * @ysize_100: The Y value which will be treated as 100%. * * Convenience function that creates a #PikaSizeEntry with two fields for x/y * coordinates/sizes with a #PikaChainButton attached to constrain either the * two fields' values or the ratio between them. * * Returns: (transfer full): The new #PikaSizeEntry. **/ GtkWidget * pika_coordinates_new (PikaUnit unit, const gchar *unit_format, gboolean menu_show_pixels, gboolean menu_show_percent, gint spinbutton_width, PikaSizeEntryUpdatePolicy update_policy, gboolean chainbutton_active, gboolean chain_constrains_ratio, const gchar *xlabel, gdouble x, gdouble xres, gdouble lower_boundary_x, gdouble upper_boundary_x, gdouble xsize_0, /* % */ gdouble xsize_100, /* % */ const gchar *ylabel, gdouble y, gdouble yres, gdouble lower_boundary_y, gdouble upper_boundary_y, gdouble ysize_0, /* % */ gdouble ysize_100 /* % */) { PikaCoordinatesData *data; GtkAdjustment *adjustment; GtkWidget *spinbutton; GtkWidget *sizeentry; GtkWidget *chainbutton; adjustment = gtk_adjustment_new (1, 0, 1, 1, 10, 0); spinbutton = pika_spin_button_new (adjustment, 1.0, 2); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spinbutton), TRUE); if (spinbutton_width > 0) { if (spinbutton_width < 17) gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), spinbutton_width); else gtk_widget_set_size_request (spinbutton, spinbutton_width, -1); } sizeentry = pika_size_entry_new (1, unit, unit_format, menu_show_pixels, menu_show_percent, FALSE, spinbutton_width, update_policy); pika_size_entry_add_field (PIKA_SIZE_ENTRY (sizeentry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_grid_attach (GTK_GRID (sizeentry), spinbutton, 1, 0, 1, 1); gtk_widget_show (spinbutton); pika_size_entry_set_unit (PIKA_SIZE_ENTRY (sizeentry), (update_policy == PIKA_SIZE_ENTRY_UPDATE_RESOLUTION) || (menu_show_pixels == FALSE) ? PIKA_UNIT_INCH : PIKA_UNIT_PIXEL); pika_size_entry_set_resolution (PIKA_SIZE_ENTRY (sizeentry), 0, xres, TRUE); pika_size_entry_set_resolution (PIKA_SIZE_ENTRY (sizeentry), 1, yres, TRUE); pika_size_entry_set_refval_boundaries (PIKA_SIZE_ENTRY (sizeentry), 0, lower_boundary_x, upper_boundary_x); pika_size_entry_set_refval_boundaries (PIKA_SIZE_ENTRY (sizeentry), 1, lower_boundary_y, upper_boundary_y); if (menu_show_percent) { pika_size_entry_set_size (PIKA_SIZE_ENTRY (sizeentry), 0, xsize_0, xsize_100); pika_size_entry_set_size (PIKA_SIZE_ENTRY (sizeentry), 1, ysize_0, ysize_100); } pika_size_entry_set_refval (PIKA_SIZE_ENTRY (sizeentry), 0, x); pika_size_entry_set_refval (PIKA_SIZE_ENTRY (sizeentry), 1, y); pika_size_entry_attach_label (PIKA_SIZE_ENTRY (sizeentry), xlabel, 0, 0, 0.0); pika_size_entry_attach_label (PIKA_SIZE_ENTRY (sizeentry), ylabel, 1, 0, 0.0); chainbutton = pika_chain_button_new (PIKA_CHAIN_RIGHT); if (chainbutton_active) pika_chain_button_set_active (PIKA_CHAIN_BUTTON (chainbutton), TRUE); gtk_grid_attach (GTK_GRID (sizeentry), chainbutton, 2, 0, 1, 2); gtk_widget_show (chainbutton); data = g_slice_new (PikaCoordinatesData); data->chainbutton = PIKA_CHAIN_BUTTON (chainbutton); data->chain_constrains_ratio = chain_constrains_ratio; data->orig_x = x; data->orig_y = y; data->last_x = x; data->last_y = y; g_object_set_data_full (G_OBJECT (sizeentry), "coordinates-data", data, (GDestroyNotify) pika_coordinates_data_free); g_signal_connect (sizeentry, "value-changed", G_CALLBACK (pika_coordinates_callback), data); g_object_set_data (G_OBJECT (sizeentry), "chainbutton", chainbutton); g_signal_connect (chainbutton, "toggled", G_CALLBACK (pika_coordinates_chainbutton_toggled), sizeentry); return sizeentry; } /* * Standard Callbacks */ /** * pika_toggle_button_update: * @widget: A #GtkToggleButton. * @data: A pointer to a #gint variable which will store the value of * gtk_toggle_button_get_active(). **/ void pika_toggle_button_update (GtkWidget *widget, gpointer data) { gint *toggle_val = (gint *) data; if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) *toggle_val = TRUE; else *toggle_val = FALSE; } /** * pika_radio_button_update: * @widget: A #GtkRadioButton. * @data: A pointer to a #gint variable which will store the value of * GPOINTER_TO_INT (g_object_get_data (@widget, "pika-item-data")). **/ void pika_radio_button_update (GtkWidget *widget, gpointer data) { if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { gint *toggle_val = (gint *) data; *toggle_val = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "pika-item-data")); } } /** * pika_int_adjustment_update: * @adjustment: A #GtkAdjustment. * @data: A pointer to a #gint variable which will store the * @adjustment's value. * * Note that the #GtkAdjustment's value (which is a #gdouble) will be * rounded with RINT(). **/ void pika_int_adjustment_update (GtkAdjustment *adjustment, gpointer data) { gint *val = (gint *) data; *val = RINT (gtk_adjustment_get_value (adjustment)); } /** * pika_uint_adjustment_update: * @adjustment: A #GtkAdjustment. * @data: A pointer to a #guint variable which will store the * @adjustment's value. * * Note that the #GtkAdjustment's value (which is a #gdouble) will be rounded * with (#guint) (value + 0.5). **/ void pika_uint_adjustment_update (GtkAdjustment *adjustment, gpointer data) { guint *val = (guint *) data; *val = (guint) (gtk_adjustment_get_value (adjustment) + 0.5); } /** * pika_float_adjustment_update: * @adjustment: A #GtkAdjustment. * @data: A pointer to a #gfloat variable which will store the * @adjustment's value. **/ void pika_float_adjustment_update (GtkAdjustment *adjustment, gpointer data) { gfloat *val = (gfloat *) data; *val = gtk_adjustment_get_value (adjustment); } /** * pika_double_adjustment_update: * @adjustment: A #GtkAdjustment. * @data: A pointer to a #gdouble variable which will store the * @adjustment's value. **/ void pika_double_adjustment_update (GtkAdjustment *adjustment, gpointer data) { gdouble *val = (gdouble *) data; *val = gtk_adjustment_get_value (adjustment); }