GtkWidget * palette_import_dialog_new (GimpContext *context) { ImportDialog *dialog; GimpGradient *gradient; GtkWidget *button; GtkWidget *main_hbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *table; GtkWidget *abox; GtkSizeGroup *size_group; GSList *group = NULL; g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); gradient = gimp_context_get_gradient (context); dialog = g_slice_new0 (ImportDialog); dialog->import_type = GRADIENT_IMPORT; dialog->context = gimp_context_new (context->gimp, "Palette Import", context); dialog->dialog = gimp_dialog_new (_("Import a New Palette"), "gimp-palette-import", NULL, 0, gimp_standard_help_func, GIMP_HELP_PALETTE_IMPORT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), _("_Import"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_icon_name ("gtk-convert", GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); g_object_set_data_full (G_OBJECT (dialog->dialog), "palette-import-dialog", dialog, (GDestroyNotify) palette_import_free); g_signal_connect (dialog->dialog, "response", G_CALLBACK (palette_import_response), dialog); gimp_dnd_viewable_dest_add (dialog->dialog, GIMP_TYPE_GRADIENT, import_dialog_drop_callback, dialog); gimp_dnd_viewable_dest_add (dialog->dialog, GIMP_TYPE_IMAGE, import_dialog_drop_callback, dialog); main_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); /* The "Source" frame */ frame = gimp_frame_new (_("Select Source")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (5, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); dialog->gradient_radio = gtk_radio_button_new_with_mnemonic (group, _("_Gradient")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->gradient_radio)); gtk_table_attach (GTK_TABLE (table), dialog->gradient_radio, 0, 1, 0, 1, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->gradient_radio); g_signal_connect (dialog->gradient_radio, "toggled", G_CALLBACK (palette_import_grad_callback), dialog); dialog->image_radio = gtk_radio_button_new_with_mnemonic (group, _("I_mage")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio)); gtk_table_attach (GTK_TABLE (table), dialog->image_radio, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->image_radio); g_signal_connect (dialog->image_radio, "toggled", G_CALLBACK (palette_import_image_callback), dialog); gtk_widget_set_sensitive (dialog->image_radio, ! gimp_container_is_empty (context->gimp->images)); dialog->sample_merged_toggle = gtk_check_button_new_with_mnemonic (_("Sample _Merged")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->sample_merged_toggle), TRUE); gtk_table_attach (GTK_TABLE (table), dialog->sample_merged_toggle, 1, 2, 2, 3, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->sample_merged_toggle); g_signal_connect_swapped (dialog->sample_merged_toggle, "toggled", G_CALLBACK (palette_import_make_palette), dialog); dialog->selection_only_toggle = gtk_check_button_new_with_mnemonic (_("_Selected Pixels only")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->selection_only_toggle), FALSE); gtk_table_attach (GTK_TABLE (table), dialog->selection_only_toggle, 1, 2, 3, 4, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->selection_only_toggle); g_signal_connect_swapped (dialog->selection_only_toggle, "toggled", G_CALLBACK (palette_import_make_palette), dialog); dialog->file_radio = gtk_radio_button_new_with_mnemonic (group, _("Palette _file")); group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (dialog->image_radio)); gtk_table_attach (GTK_TABLE (table), dialog->file_radio, 0, 1, 4, 5, GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (dialog->file_radio); g_signal_connect (dialog->file_radio, "toggled", G_CALLBACK (palette_import_file_callback), dialog); size_group = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL); /* The gradient menu */ dialog->gradient_combo = gimp_container_combo_box_new (gimp_data_factory_get_container (context->gimp->gradient_factory), dialog->context, 24, 1); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, NULL, 0.0, 0.5, dialog->gradient_combo, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->gradient_combo); /* The image menu */ dialog->image_combo = gimp_container_combo_box_new (context->gimp->images, dialog->context, 24, 1); gimp_table_attach_aligned (GTK_TABLE (table), 0, 1, NULL, 0.0, 0.5, dialog->image_combo, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->image_combo); /* Palette file name entry */ dialog->file_chooser = gtk_file_chooser_button_new (_("Select Palette File"), GTK_FILE_CHOOSER_ACTION_OPEN); gimp_table_attach_aligned (GTK_TABLE (table), 0, 4, NULL, 0.0, 0.5, dialog->file_chooser, 1, FALSE); gtk_size_group_add_widget (size_group, dialog->file_chooser); g_object_unref (size_group); /* The "Import" frame */ frame = gimp_frame_new (_("Import Options")); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); /* The source's name */ dialog->entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (dialog->entry), gradient ? gimp_object_get_name (gradient) : _("New import")); gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("Palette _name:"), 0.0, 0.5, dialog->entry, 2, FALSE); /* The # of colors */ dialog->num_colors = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("N_umber of colors:"), -1, 5, 256, 2, 10000, 1, 10, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect_swapped (dialog->num_colors, "value-changed", G_CALLBACK (palette_import_make_palette), dialog); /* The columns */ dialog->columns = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("C_olumns:"), -1, 5, 16, 0, 64, 1, 8, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect (dialog->columns, "value-changed", G_CALLBACK (palette_import_columns_changed), dialog); /* The interval */ dialog->threshold = GTK_ADJUSTMENT (gimp_scale_entry_new (GTK_TABLE (table), 0, 3, _("I_nterval:"), -1, 5, 1, 1, 128, 1, 8, 0, TRUE, 0.0, 0.0, NULL, NULL)); g_signal_connect_swapped (dialog->threshold, "value-changed", G_CALLBACK (palette_import_make_palette), dialog); /* The "Preview" frame */ frame = gimp_frame_new (_("Preview")); gtk_box_pack_start (GTK_BOX (main_hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); abox = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); dialog->preview = gimp_view_new_full_by_types (dialog->context, GIMP_TYPE_VIEW, GIMP_TYPE_PALETTE, 192, 192, 1, TRUE, FALSE, FALSE); gtk_container_add (GTK_CONTAINER (abox), dialog->preview); gtk_widget_show (dialog->preview); dialog->no_colors_label = gtk_label_new (_("The selected source contains no colors.")); gtk_widget_set_size_request (dialog->no_colors_label, 194, -1); gtk_label_set_line_wrap (GTK_LABEL (dialog->no_colors_label), TRUE); gimp_label_set_attributes (GTK_LABEL (dialog->no_colors_label), PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC, -1); gtk_box_pack_start (GTK_BOX (vbox), dialog->no_colors_label, FALSE, FALSE, 0); gtk_widget_show (dialog->no_colors_label); /* keep the dialog up-to-date */ g_signal_connect (context->gimp->images, "add", G_CALLBACK (palette_import_image_add), dialog); g_signal_connect (context->gimp->images, "remove", G_CALLBACK (palette_import_image_remove), dialog); g_signal_connect (dialog->context, "gradient-changed", G_CALLBACK (palette_import_gradient_changed), dialog); g_signal_connect (dialog->context, "image-changed", G_CALLBACK (palette_import_image_changed), dialog); g_signal_connect (dialog->file_chooser, "selection-changed", G_CALLBACK (palette_import_filename_changed), dialog); palette_import_grad_callback (dialog->gradient_radio, dialog); return dialog->dialog; }
static void create_effects_frame (GtkWidget *outer_vbox, const gchar *frame_title) { GtkWidget *main_vbox, *vbox, *hbox; GtkWidget *align; GtkWidget *label; GtkWidget *check; GtkWidget *combo; gchar *title; #if GTK_CHECK_VERSION (3, 0, 0) main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else main_vbox = gtk_vbox_new (FALSE, 6); #endif gtk_widget_set_sensitive (main_vbox, !take_area_shot); gtk_box_pack_start (GTK_BOX (outer_vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); effects_vbox = main_vbox; title = g_strconcat ("<b>", frame_title, "</b>", NULL); label = gtk_label_new (title); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_yalign (GTK_LABEL (label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); g_free (title); #if GTK_CHECK_VERSION (3, 0, 0) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else hbox = gtk_hbox_new (FALSE, 12); #endif gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); align = gtk_alignment_new (0.0, 0.0, 0.0, 0.0); gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 12, 0); gtk_box_pack_start (GTK_BOX (hbox), align, FALSE, FALSE, 0); gtk_widget_show (align); #if GTK_CHECK_VERSION (3, 0, 0) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif gtk_container_add (GTK_CONTAINER (align), vbox); gtk_widget_show (vbox); /** Include pointer **/ check = gtk_check_button_new_with_mnemonic (_("Include _pointer")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), include_pointer); g_signal_connect (check, "toggled", G_CALLBACK (include_pointer_toggled_cb), NULL); gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0); gtk_widget_show (check); /** Include window border **/ check = gtk_check_button_new_with_mnemonic (_("Include the window _border")); gtk_widget_set_sensitive (check, take_window_shot); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check), include_border); g_signal_connect (check, "toggled", G_CALLBACK (include_border_toggled_cb), NULL); gtk_box_pack_start (GTK_BOX (vbox), check, FALSE, FALSE, 0); gtk_widget_show (check); border_check = check; /** Effects **/ #if GTK_CHECK_VERSION (3, 0, 0) hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else hbox = gtk_hbox_new (FALSE, 12); #endif gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Apply _effect:")); gtk_widget_set_sensitive (label, take_window_shot); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_yalign (GTK_LABEL (label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); #endif gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); effect_label = label; combo = create_effects_combo (); gtk_widget_set_sensitive (combo, take_window_shot); gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gtk_widget_show (combo); effect_combo = combo; }
static gint dog_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *button; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *coord; GimpUnit unit; gdouble xres; gdouble yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("DoG Edge Detect"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start_defaults (GTK_BOX (main_vbox), preview); gtk_widget_show (preview); g_signal_connect (preview, "invalidated", G_CALLBACK (preview_update_preview), drawable); frame = gimp_frame_new (_("Smoothing Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* Get the image resolution and unit */ gimp_image_get_resolution (image_ID, &xres, &yres); unit = gimp_image_get_unit (image_ID); coord = gimp_coordinates_new (unit, "%a", TRUE, FALSE, -1, GIMP_SIZE_ENTRY_UPDATE_SIZE, FALSE, TRUE, _("_Radius 1:"), dogvals.inner, xres, 0, 8 * MAX (drawable->width, drawable->height), 0, 0, _("R_adius 2:"), dogvals.outer, yres, 0, 8 * MAX (drawable->width, drawable->height), 0, 0); gtk_container_add (GTK_CONTAINER (frame), coord); gtk_widget_show (coord); gimp_size_entry_set_pixel_digits (GIMP_SIZE_ENTRY (coord), 1); g_signal_connect (coord, "value-changed", G_CALLBACK (change_radius_callback), preview); button = gtk_check_button_new_with_mnemonic (_("_Normalize")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.normalize); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dogvals.normalize); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (button); button = gtk_check_button_new_with_mnemonic (_("_Invert")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), dogvals.invert); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &dogvals.invert); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (button); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { dogvals.inner = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 0); dogvals.outer = gimp_size_entry_get_refval (GIMP_SIZE_ENTRY (coord), 1); } gtk_widget_destroy (dialog); return run; }
static void mateweather_pref_create(MateWeatherPref* pref) { GtkWidget* pref_vbox; GtkWidget* pref_notebook; #ifdef RADARMAP GtkWidget* radar_toggle_hbox; #endif /* RADARMAP */ GtkWidget* pref_basic_update_alignment; GtkWidget* pref_basic_update_lbl; GtkWidget* pref_basic_update_hbox; GObject* pref_basic_update_spin_adj; GtkWidget* pref_basic_update_sec_lbl; GtkWidget* pref_basic_note_lbl; GtkWidget* pref_loc_hbox; GtkWidget* pref_loc_note_lbl; GtkWidget* scrolled_window; GtkWidget* label; GtkWidget* value_hbox; GtkWidget* tree_label; GtkTreeSelection *selection; GtkWidget* pref_basic_vbox; GtkWidget* vbox; GtkWidget* frame; GtkWidget* temp_label; GtkWidget* temp_combo; GtkWidget* speed_label; GtkWidget* speed_combo; GtkWidget* pres_label; GtkWidget* pres_combo; GtkWidget* dist_label; GtkWidget* dist_combo; #if GTK_CHECK_VERSION (3, 0, 0) GtkWidget* unit_grid; #else GtkWidget* unit_table; #endif GtkWidget* pref_find_label; GtkWidget* pref_find_hbox; GtkWidget* image; g_object_set (pref, "destroy-with-parent", TRUE, NULL); gtk_window_set_title (GTK_WINDOW (pref), _("Weather Preferences")); gtk_dialog_add_buttons (GTK_DIALOG (pref), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_dialog_set_default_response (GTK_DIALOG (pref), GTK_RESPONSE_CLOSE); gtk_container_set_border_width (GTK_CONTAINER (pref), 5); gtk_window_set_resizable (GTK_WINDOW (pref), TRUE); gtk_window_set_screen (GTK_WINDOW (pref), gtk_widget_get_screen (GTK_WIDGET (pref->priv->applet->applet))); pref_vbox = gtk_dialog_get_content_area (GTK_DIALOG (pref)); gtk_box_set_spacing (GTK_BOX (pref_vbox), 2); gtk_widget_show (pref_vbox); pref_notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (pref_notebook), 5); gtk_widget_show (pref_notebook); gtk_box_pack_start (GTK_BOX (pref_vbox), pref_notebook, TRUE, TRUE, 0); /* * General settings page. */ #if GTK_CHECK_VERSION (3, 0, 0) pref_basic_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); #else pref_basic_vbox = gtk_vbox_new (FALSE, 18); #endif gtk_container_set_border_width (GTK_CONTAINER (pref_basic_vbox), 12); gtk_container_add (GTK_CONTAINER (pref_notebook), pref_basic_vbox); pref_basic_update_alignment = gtk_alignment_new (0, 0.5, 0, 1); gtk_widget_show (pref_basic_update_alignment); pref->priv->basic_update_btn = gtk_check_button_new_with_mnemonic (_("_Automatically update every:")); gtk_widget_show (pref->priv->basic_update_btn); gtk_container_add (GTK_CONTAINER (pref_basic_update_alignment), pref->priv->basic_update_btn); g_signal_connect (G_OBJECT (pref->priv->basic_update_btn), "toggled", G_CALLBACK (auto_update_toggled), pref); if (!g_settings_is_writable (pref->priv->applet->settings, "auto-update")) { hard_set_sensitive (pref->priv->basic_update_btn, FALSE); } /* * Units settings page. */ /* Temperature Unit */ temp_label = gtk_label_new_with_mnemonic (_("_Temperature unit:")); gtk_label_set_use_markup (GTK_LABEL (temp_label), TRUE); gtk_label_set_justify (GTK_LABEL (temp_label), GTK_JUSTIFY_LEFT); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (temp_label), 0.0, 0.5); #endif gtk_widget_show (temp_label); temp_combo = gtk_combo_box_text_new (); pref->priv->basic_temp_combo = temp_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (temp_label), temp_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (temp_combo), _("Default")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Kelvin")); /* TRANSLATORS: Celsius is sometimes referred Centigrade */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Celsius")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (temp_combo), _("Fahrenheit")); gtk_widget_show (temp_combo); if ( ! g_settings_is_writable (pref->priv->applet->settings, "temperature-unit")) { hard_set_sensitive (pref->priv->basic_temp_combo, FALSE); } /* Speed Unit */ speed_label = gtk_label_new_with_mnemonic (_("_Wind speed unit:")); gtk_label_set_use_markup (GTK_LABEL (speed_label), TRUE); gtk_label_set_justify (GTK_LABEL (speed_label), GTK_JUSTIFY_LEFT); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (speed_label), 0.0, 0.5); #endif gtk_widget_show (speed_label); speed_combo = gtk_combo_box_text_new (); pref->priv->basic_speed_combo = speed_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (speed_label), speed_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (speed_combo), _("Default")); /* TRANSLATOR: The wind speed unit "meters per second" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("m/s")); /* TRANSLATOR: The wind speed unit "kilometers per hour" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("km/h")); /* TRANSLATOR: The wind speed unit "miles per hour" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("mph")); /* TRANSLATOR: The wind speed unit "knots" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("knots")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (speed_combo), _("Beaufort scale")); gtk_widget_show (speed_combo); if (!g_settings_is_writable (pref->priv->applet->settings, "speed-unit")) { hard_set_sensitive (pref->priv->basic_speed_combo, FALSE); } /* Pressure Unit */ pres_label = gtk_label_new_with_mnemonic (_("_Pressure unit:")); gtk_label_set_use_markup (GTK_LABEL (pres_label), TRUE); gtk_label_set_justify (GTK_LABEL (pres_label), GTK_JUSTIFY_LEFT); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (pres_label), 0.0, 0.5); #endif gtk_widget_show (pres_label); pres_combo = gtk_combo_box_text_new (); pref->priv->basic_pres_combo = pres_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (pres_label), pres_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (pres_combo), _("Default")); /* TRANSLATOR: The pressure unit "kiloPascals" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("kPa")); /* TRANSLATOR: The pressure unit "hectoPascals" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("hPa")); /* TRANSLATOR: The pressure unit "millibars" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("mb")); /* TRANSLATOR: The pressure unit "millibars of mercury" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("mmHg")); /* TRANSLATOR: The pressure unit "inches of mercury" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("inHg")); /* TRANSLATOR: The pressure unit "atmospheres" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (pres_combo), _("atm")); gtk_widget_show (pres_combo); if (!g_settings_is_writable(pref->priv->applet->settings, "pressure-unit")) { hard_set_sensitive(pref->priv->basic_pres_combo, FALSE); } /* Distance Unit */ dist_label = gtk_label_new_with_mnemonic (_("_Visibility unit:")); gtk_label_set_use_markup (GTK_LABEL (dist_label), TRUE); gtk_label_set_justify (GTK_LABEL (dist_label), GTK_JUSTIFY_LEFT); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (dist_label), 0, 0.5); #endif gtk_widget_show (dist_label); dist_combo = gtk_combo_box_text_new (); pref->priv->basic_dist_combo = dist_combo; gtk_label_set_mnemonic_widget (GTK_LABEL (dist_label), dist_combo); //gtk_combo_box_append_text (GTK_COMBO_BOX (dist_combo), _("Default")); /* TRANSLATOR: The distance unit "meters" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("meters")); /* TRANSLATOR: The distance unit "kilometers" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("km")); /* TRANSLATOR: The distance unit "miles" */ gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (dist_combo), _("miles")); gtk_widget_show (dist_combo); if ( ! g_settings_is_writable (pref->priv->applet->settings, "distance-unit")) hard_set_sensitive (pref->priv->basic_dist_combo, FALSE); #if GTK_CHECK_VERSION (3, 0, 0) unit_grid = gtk_grid_new (); gtk_grid_set_row_spacing(GTK_GRID(unit_grid), 6); gtk_grid_set_column_spacing(GTK_GRID(unit_grid), 12); gtk_widget_set_halign (temp_label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(unit_grid), temp_label, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(unit_grid), temp_combo, 1, 0, 1, 1); gtk_widget_set_halign (speed_label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(unit_grid), speed_label, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(unit_grid), speed_combo, 1, 1, 1, 1); gtk_widget_set_halign (pres_label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(unit_grid), pres_label, 0, 2, 1, 1); gtk_grid_attach(GTK_GRID(unit_grid), pres_combo, 1, 2, 1, 1); gtk_widget_set_halign (dist_label, GTK_ALIGN_START); gtk_grid_attach(GTK_GRID(unit_grid), dist_label, 0, 3, 1, 1); gtk_grid_attach(GTK_GRID(unit_grid), dist_combo, 1, 3, 1, 1); gtk_widget_show(unit_grid); #else unit_table = gtk_table_new(5, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(unit_table), 6); gtk_table_set_col_spacings(GTK_TABLE(unit_table), 12); gtk_table_attach(GTK_TABLE(unit_table), temp_label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), temp_combo, 1, 2, 0, 1); gtk_table_attach(GTK_TABLE(unit_table), speed_label, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), speed_combo, 1, 2, 1, 2); gtk_table_attach(GTK_TABLE(unit_table), pres_label, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), pres_combo, 1, 2, 2, 3); gtk_table_attach(GTK_TABLE(unit_table), dist_label, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_table_attach_defaults(GTK_TABLE(unit_table), dist_combo, 1, 2, 3, 4); gtk_widget_show(unit_table); #endif g_signal_connect (temp_combo, "changed", G_CALLBACK (temp_combo_changed_cb), pref); g_signal_connect (speed_combo, "changed", G_CALLBACK (speed_combo_changed_cb), pref); g_signal_connect (dist_combo, "changed", G_CALLBACK (dist_combo_changed_cb), pref); g_signal_connect (pres_combo, "changed", G_CALLBACK (pres_combo_changed_cb), pref); #ifdef RADARMAP pref->priv->basic_radar_btn = gtk_check_button_new_with_mnemonic (_("Enable _radar map")); gtk_widget_show (pref->priv->basic_radar_btn); g_signal_connect (G_OBJECT (pref->priv->basic_radar_btn), "toggled", G_CALLBACK (radar_toggled), pref); if (!g_settings_is_writable (pref->priv->applet->settings, "enable-radar-map")) { hard_set_sensitive(pref->priv->basic_radar_btn, FALSE); } #if GTK_CHECK_VERSION (3, 0, 0) radar_toggle_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 12); #else radar_toggle_hbox = gtk_hbox_new(FALSE, 12); #endif gtk_widget_show(radar_toggle_hbox); label = gtk_label_new (" "); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), label, FALSE, FALSE, 0); pref->priv->basic_radar_url_btn = gtk_check_button_new_with_mnemonic (_("Use _custom address for radar map")); gtk_widget_show (pref->priv->basic_radar_url_btn); gtk_box_pack_start (GTK_BOX (radar_toggle_hbox), pref->priv->basic_radar_url_btn, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_btn), "toggled", G_CALLBACK (use_radar_url_toggled), pref); if ( ! g_settings_is_writable (pref->priv->applet->settings, "use-custom-radar-url")) { hard_set_sensitive (pref->priv->basic_radar_url_btn, FALSE); } #if GTK_CHECK_VERSION (3, 0, 0) pref->priv->basic_radar_url_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else pref->priv->basic_radar_url_hbox = gtk_hbox_new (FALSE, 12); #endif gtk_widget_show (pref->priv->basic_radar_url_hbox); label = gtk_label_new (" "); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("A_ddress:")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), label, FALSE, FALSE, 0); pref->priv->basic_radar_url_entry = gtk_entry_new (); gtk_widget_show (pref->priv->basic_radar_url_entry); gtk_box_pack_start (GTK_BOX (pref->priv->basic_radar_url_hbox), pref->priv->basic_radar_url_entry, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (pref->priv->basic_radar_url_entry), "focus_out_event", G_CALLBACK (radar_url_changed), pref); if ( ! g_settings_is_writable (pref->priv->applet->settings, "radar")) { hard_set_sensitive (pref->priv->basic_radar_url_entry, FALSE); } #endif /* RADARMAP */ #ifdef HAVE_LIBNOTIFY /* setup show-notifications button */ pref->priv->basic_show_notifications_btn = gtk_check_button_new_with_mnemonic (_("Show _notifications")); if (!g_settings_is_writable (pref->priv->applet->settings, "show-notifications")) { hard_set_sensitive (pref->priv->basic_show_notifications_btn, FALSE); } g_signal_connect (G_OBJECT (pref->priv->basic_show_notifications_btn), "toggled", G_CALLBACK (show_notifications_toggled), pref); #endif frame = create_hig_category (pref_basic_vbox, _("Update")); #if GTK_CHECK_VERSION (3, 0, 0) pref_basic_update_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); #else pref_basic_update_hbox = gtk_hbox_new (FALSE, 12); #endif pref_basic_update_lbl = gtk_label_new_with_mnemonic (_("_Automatically update every:")); gtk_widget_show (pref_basic_update_lbl); gtk_widget_show (pref_basic_update_hbox); pref_basic_update_spin_adj = gtk_adjustment_new (30, 1, 3600, 5, 25, 1); pref->priv->basic_update_spin = gtk_spin_button_new (GTK_ADJUSTMENT (pref_basic_update_spin_adj), 1, 0); gtk_widget_show (pref->priv->basic_update_spin); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), TRUE); gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (pref->priv->basic_update_spin), GTK_UPDATE_IF_VALID); g_signal_connect (G_OBJECT (pref->priv->basic_update_spin), "value_changed", G_CALLBACK (update_interval_changed), pref); pref_basic_update_sec_lbl = gtk_label_new (_("minutes")); gtk_widget_show (pref_basic_update_sec_lbl); if ( ! g_settings_is_writable (pref->priv->applet->settings, "auto-update-interval")) { hard_set_sensitive (pref->priv->basic_update_spin, FALSE); hard_set_sensitive (pref_basic_update_sec_lbl, FALSE); } #if GTK_CHECK_VERSION (3, 0, 0) value_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); #else value_hbox = gtk_hbox_new (FALSE, 6); #endif gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), pref_basic_update_alignment, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (pref_basic_update_hbox), value_hbox, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (value_hbox), pref->priv->basic_update_spin, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (value_hbox), pref_basic_update_sec_lbl, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), pref_basic_update_hbox); frame = create_hig_category (pref_basic_vbox, _("Display")); #if GTK_CHECK_VERSION (3, 0, 0) vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else vbox = gtk_vbox_new (FALSE, 6); #endif #if GTK_CHECK_VERSION (3, 0, 0) gtk_box_pack_start (GTK_BOX (vbox), unit_grid, TRUE, TRUE, 0); #else gtk_box_pack_start (GTK_BOX (vbox), unit_table, TRUE, TRUE, 0); #endif #ifdef RADARMAP gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_btn, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), radar_toggle_hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_radar_url_hbox, TRUE, TRUE, 0); #endif /* RADARMAP */ #ifdef HAVE_LIBNOTIFY /* add the show-notification toggle button to the vbox of the display section */ gtk_box_pack_start (GTK_BOX (vbox), pref->priv->basic_show_notifications_btn, TRUE, TRUE, 0); #endif gtk_container_add (GTK_CONTAINER (frame), vbox); pref_basic_note_lbl = gtk_label_new (_("General")); gtk_widget_show (pref_basic_note_lbl); gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 0), pref_basic_note_lbl); /* * Location page. */ #if GTK_CHECK_VERSION (3, 0, 0) pref_loc_hbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); #else pref_loc_hbox = gtk_vbox_new (FALSE, 6); #endif gtk_container_set_border_width (GTK_CONTAINER (pref_loc_hbox), 12); gtk_container_add (GTK_CONTAINER (pref_notebook), pref_loc_hbox); tree_label = gtk_label_new_with_mnemonic (_("_Select a location:")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (tree_label), 0.0); #else gtk_misc_set_alignment (GTK_MISC (tree_label), 0.0, 0.5); #endif gtk_box_pack_start (GTK_BOX (pref_loc_hbox), tree_label, FALSE, FALSE, 0); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); pref->priv->tree = gtk_tree_view_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (tree_label), GTK_WIDGET (pref->priv->tree)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (pref->priv->tree), FALSE); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pref->priv->tree)); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (row_selected_cb), pref); gtk_container_add (GTK_CONTAINER (scrolled_window), pref->priv->tree); gtk_widget_show (pref->priv->tree); gtk_widget_show (scrolled_window); gtk_box_pack_start (GTK_BOX (pref_loc_hbox), scrolled_window, TRUE, TRUE, 0); load_locations(pref); #if GTK_CHECK_VERSION (3, 0, 0) pref_find_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); #else pref_find_hbox = gtk_hbox_new (FALSE, 6); #endif pref_find_label = gtk_label_new (_("_Find:")); gtk_label_set_use_underline (GTK_LABEL (pref_find_label), TRUE); pref->priv->find_entry = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (pref_find_label), pref->priv->find_entry); pref->priv->find_next_btn = gtk_button_new_with_mnemonic (_("Find _Next")); gtk_widget_set_sensitive (pref->priv->find_next_btn, FALSE); image = gtk_image_new_from_stock (GTK_STOCK_FIND, GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (pref->priv->find_next_btn), image); g_signal_connect (G_OBJECT (pref->priv->find_next_btn), "clicked", G_CALLBACK (find_next_clicked), pref); g_signal_connect (G_OBJECT (pref->priv->find_entry), "changed", G_CALLBACK (find_entry_changed), pref); gtk_container_set_border_width (GTK_CONTAINER (pref_find_hbox), 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref_find_label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (pref_find_hbox), pref->priv->find_next_btn, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (pref_loc_hbox), pref_find_hbox, FALSE, FALSE, 0); if ( ! g_settings_is_writable (pref->priv->applet->settings, "location0")) { hard_set_sensitive (scrolled_window, FALSE); } pref_loc_note_lbl = gtk_label_new (_("Location")); gtk_widget_show (pref_loc_note_lbl); gtk_notebook_set_tab_label (GTK_NOTEBOOK (pref_notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (pref_notebook), 1), pref_loc_note_lbl); g_signal_connect (G_OBJECT (pref), "response", G_CALLBACK (response_cb), pref); mateweather_pref_set_accessibility (pref); gtk_label_set_mnemonic_widget (GTK_LABEL (pref_basic_update_sec_lbl), pref->priv->basic_update_spin); gtk_label_set_mnemonic_widget (GTK_LABEL (label), pref->priv->basic_radar_url_entry); }
static gboolean mblur_dialog (gint32 image_ID, GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *frame; GtkWidget *table; GtkWidget *entry; GtkWidget *spinbutton; GtkWidget *label; GtkWidget *button; GtkObject *adj; gdouble xres, yres; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Motion Blur"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect_swapped (preview, "invalidated", G_CALLBACK (mblur), drawable); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); frame = gimp_int_radio_group_new (TRUE, _("Blur Type"), G_CALLBACK (mblur_radio_button_update), &mbvals.mblur_type, mbvals.mblur_type, _("_Linear"), MBLUR_LINEAR, NULL, _("_Radial"), MBLUR_RADIAL, NULL, _("_Zoom"), MBLUR_ZOOM, NULL, NULL); gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); center = gimp_frame_new (_("Blur Center")); gtk_box_pack_start (GTK_BOX (hbox), center, FALSE, FALSE, 0); gtk_widget_show (center); vbox = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (center), vbox); gtk_widget_show (vbox); gimp_image_get_resolution (image_ID, &xres, &yres); entry = gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 5, GIMP_SIZE_ENTRY_UPDATE_SIZE); gtk_table_set_row_spacings (GTK_TABLE (entry), 2); gtk_table_set_col_spacing (GTK_TABLE (entry), 0, 6); gtk_table_set_col_spacing (GTK_TABLE (entry), 2, 6); gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0); gtk_widget_show (entry); g_signal_connect (entry, "value-changed", G_CALLBACK (mblur_center_update), NULL); g_signal_connect_swapped (entry, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); spinbutton = gimp_spin_button_new (&adj, 1, 0, 1, 1, 10, 1, 1, 2); gimp_size_entry_add_field (GIMP_SIZE_ENTRY (entry), GTK_SPIN_BUTTON (spinbutton), NULL); gtk_table_attach_defaults (GTK_TABLE (entry), spinbutton, 1, 2, 0, 1); gtk_widget_show (spinbutton); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 0, xres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 0, mbvals.center_x); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_X:"), 0, 0, 0.0); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (entry), 1, yres, TRUE); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (entry), 1, mbvals.center_y); label = gimp_size_entry_attach_label (GIMP_SIZE_ENTRY (entry), _("_Y:"), 1, 0, 0.0); button = gtk_check_button_new_with_mnemonic (_("Blur _outward")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), mbvals.blur_outward); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "toggled", G_CALLBACK (gimp_toggle_button_update), &mbvals.blur_outward); g_signal_connect_swapped (button, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); dir_button = button; frame = gimp_frame_new (_("Blur Parameters")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); gtk_widget_show (table); length = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("L_ength:"), 150, 3, mbvals.length, 1.0, MBLUR_LENGTH_MAX, 1.0, 8.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (length, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.length); g_signal_connect_swapped (length, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); angle = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Angle:"), 150, 3, mbvals.angle, 0.0, 360.0, 1.0, 15.0, 0, TRUE, 0, 0, NULL, NULL); g_signal_connect (angle, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &mbvals.angle); g_signal_connect_swapped (angle, "value-changed", G_CALLBACK (gimp_preview_invalidate), preview); mblur_set_sensitivity (); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static inline GtkWidget *rc_ui_settings_appearance_build( RCUiSettingsPrivate *priv) { GtkWidget *appearance_grid; GtkWidget *frame_label; GtkWidget *theme_frame; GtkWidget *theme_frame_grid; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeIter iter; GSList *theme_list, *foreach; const gchar *embedded_theme_name; guint theme_number; guint i; const gchar *path; gchar *theme_name; gchar *theme_settings; gboolean theme_embedded_flag = FALSE; appearance_grid = gtk_grid_new(); theme_frame = gtk_frame_new(NULL); frame_label = gtk_label_new(NULL); store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING); renderer = gtk_cell_renderer_text_new(); priv->apr_disthm_check_button = gtk_check_button_new_with_mnemonic( _("Disable theme (need to restart the player)")); priv->apr_theme_combo_box = gtk_combo_box_new_with_model( GTK_TREE_MODEL(store)); g_object_unref(store); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->apr_theme_combo_box), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(priv->apr_theme_combo_box), renderer, "text", 0, NULL); gtk_label_set_markup(GTK_LABEL(frame_label), _("<b>Theme</b>")); g_object_set(theme_frame, "label-widget", frame_label, "shadow-type", GTK_SHADOW_NONE, "hexpand-set", TRUE, "hexpand", TRUE, NULL); theme_frame_grid = gtk_grid_new(); g_object_set(priv->apr_theme_combo_box, "margin-left", 2, "margin-right", 2, "margin-top", 2, "margin-bottom", 2, "hexpand-set", TRUE, "hexpand", TRUE, NULL); theme_settings = rclib_settings_get_string("MainUI", "Theme", NULL); if(theme_settings!=NULL) { theme_embedded_flag = g_str_has_prefix(theme_settings, "embedded-theme:"); } theme_number = rc_ui_style_embedded_theme_get_length(); for(i=0;i<theme_number;i++) { embedded_theme_name = rc_ui_style_embedded_theme_get_name(i); theme_name = g_strdup_printf(_("%s (Embedded)"), embedded_theme_name); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, theme_name, 1, TRUE, 2, embedded_theme_name, -1); g_free(theme_name); if(theme_embedded_flag) { if(g_strcmp0(theme_settings+14, embedded_theme_name)==0) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX( priv->apr_theme_combo_box), &iter); } } } theme_list = rc_ui_style_search_theme_paths(); for(foreach=theme_list;foreach!=NULL;foreach=g_slist_next(foreach)) { path = foreach->data; if(path==NULL) continue; theme_name = g_path_get_basename(path); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, theme_name, 1, FALSE, 2, path, -1); g_free(theme_name); if(g_strcmp0(theme_settings, path)==0) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX( priv->apr_theme_combo_box), &iter); } } if(theme_list!=NULL) g_slist_free_full(theme_list, g_free); g_free(theme_settings); if(gtk_combo_box_get_active(GTK_COMBO_BOX(priv->apr_theme_combo_box))<0) gtk_combo_box_set_active(GTK_COMBO_BOX(priv->apr_theme_combo_box), 0); if(rclib_settings_get_boolean("MainUI", "DisableTheme", NULL)) { g_object_set(priv->apr_theme_combo_box, "sensitive", FALSE, NULL); g_object_set(priv->apr_disthm_check_button, "active", TRUE, NULL); } gtk_grid_attach(GTK_GRID(theme_frame_grid), priv->apr_disthm_check_button, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(theme_frame_grid), priv->apr_theme_combo_box, 0, 1, 1, 1); gtk_container_add(GTK_CONTAINER(theme_frame), theme_frame_grid); gtk_grid_attach(GTK_GRID(appearance_grid), theme_frame, 0, 0, 1, 1); g_signal_connect(priv->apr_theme_combo_box, "changed", G_CALLBACK(rc_ui_settings_apr_theme_changed), NULL); g_signal_connect(priv->apr_disthm_check_button, "toggled", G_CALLBACK(rc_ui_settings_apr_disthm_toggled), NULL); return appearance_grid; }
static GtkWidget * get_config_frame(PurplePlugin *plugin) { GtkWidget *ret = NULL, *frame = NULL; GtkWidget *vbox = NULL, *hbox = NULL; GtkWidget *toggle = NULL, *entry = NULL, *ref; ret = gtk_vbox_new(FALSE, 18); gtk_container_set_border_width(GTK_CONTAINER (ret), 12); /*---------- "Notify For" ----------*/ frame = pidgin_make_frame(ret, _("Notify For")); vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(frame), vbox); toggle = gtk_check_button_new_with_mnemonic(_("_IM windows")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/type_im")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(type_toggle_cb), "type_im"); toggle = gtk_check_button_new_with_mnemonic(_("C_hat windows")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/type_chat")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(type_toggle_cb), "type_chat"); ref = toggle; toggle = gtk_check_button_new_with_mnemonic(_("\t_Only when someone says your username")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/type_chat_nick")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(type_toggle_cb), "type_chat_nick"); gtk_widget_set_sensitive(toggle, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ref))); g_signal_connect(G_OBJECT(ref), "toggled", G_CALLBACK(pidgin_toggle_sensitive), toggle); toggle = gtk_check_button_new_with_mnemonic(_("_Focused windows")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/type_focused")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(type_toggle_cb), "type_focused"); /*---------- "Notification Methods" ----------*/ frame = pidgin_make_frame(ret, _("Notification Methods")); vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(frame), vbox); /* String method button */ hbox = gtk_hbox_new(FALSE, 18); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0); toggle = gtk_check_button_new_with_mnemonic(_("Prepend _string into window title:")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/method_string")); gtk_box_pack_start(GTK_BOX(hbox), toggle, FALSE, FALSE, 0); entry = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 0); gtk_entry_set_max_length(GTK_ENTRY(entry), 10); gtk_widget_set_sensitive(GTK_WIDGET(entry), purple_prefs_get_bool("/plugins/gtk/X11/notify/method_string")); gtk_entry_set_text(GTK_ENTRY(entry), purple_prefs_get_string("/plugins/gtk/X11/notify/title_string")); g_object_set_data(G_OBJECT(toggle), "title-entry", entry); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(method_toggle_cb), "method_string"); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(options_entry_cb), "method_string"); /* Count method button */ toggle = gtk_check_button_new_with_mnemonic(_("Insert c_ount of new messages into window title")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/method_count")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(method_toggle_cb), "method_count"); #ifndef _WIN32 /* Count xprop method button */ toggle = gtk_check_button_new_with_mnemonic(_("Insert count of new message into _X property")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/method_count_xprop")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(method_toggle_cb), "method_count_xprop"); /* Urgent method button */ toggle = gtk_check_button_new_with_mnemonic(_("Set window manager \"_URGENT\" hint")); #else toggle = gtk_check_button_new_with_mnemonic(_("_Flash window")); #endif gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/method_urgent")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(method_toggle_cb), "method_urgent"); /* Raise window method button */ toggle = gtk_check_button_new_with_mnemonic(_("R_aise conversation window")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/method_raise")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(method_toggle_cb), "method_raise"); /* Present conversation method button */ toggle = gtk_check_button_new_with_mnemonic(_("_Present conversation window")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/method_present")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(method_toggle_cb), "method_present"); /*---------- "Notification Removals" ----------*/ frame = pidgin_make_frame(ret, _("Notification Removal")); vbox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(frame), vbox); /* Remove on focus button */ toggle = gtk_check_button_new_with_mnemonic(_("Remove when conversation window _gains focus")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_focus")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(notify_toggle_cb), "notify_focus"); /* Remove on click button */ toggle = gtk_check_button_new_with_mnemonic(_("Remove when conversation window _receives click")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_click")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(notify_toggle_cb), "notify_click"); /* Remove on type button */ toggle = gtk_check_button_new_with_mnemonic(_("Remove when _typing in conversation window")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_type")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(notify_toggle_cb), "notify_type"); /* Remove on message send button */ toggle = gtk_check_button_new_with_mnemonic(_("Remove when a _message gets sent")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_send")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(notify_toggle_cb), "notify_send"); #if 0 /* Remove on conversation switch button */ toggle = gtk_check_button_new_with_mnemonic(_("Remove on switch to conversation ta_b")); gtk_box_pack_start(GTK_BOX(vbox), toggle, FALSE, FALSE, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toggle), purple_prefs_get_bool("/plugins/gtk/X11/notify/notify_switch")); g_signal_connect(G_OBJECT(toggle), "toggled", G_CALLBACK(notify_toggle_cb), "notify_switch"); #endif gtk_widget_show_all(ret); return ret; }
void Boolean3OptionView::_createItem() { myCheckBox = GTK_CHECK_BUTTON(gtk_check_button_new_with_mnemonic(gtkString(name()).c_str())); setState(((ZLBoolean3OptionEntry&)*myOption).initialState()); g_signal_connect(GTK_WIDGET(myCheckBox), "released", G_CALLBACK(_onReleased), this); myHolder.attachWidget(*this, GTK_WIDGET(myCheckBox)); }
void create_orientmap_dialog (GtkWidget *parent) { GtkWidget *tmpw, *tmpw2; GtkWidget *table1, *table2; GtkWidget *frame; GtkWidget *ebox, *hbox, *vbox; init_vectors (); if (orient_map_window) { update_vector_prev (); update_orient_map_preview_prev (); gtk_widget_show (orient_map_window); return; } orient_map_window = gimp_dialog_new (_("Orientation Map Editor"), PLUG_IN_BINARY, gtk_widget_get_toplevel (parent), 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_APPLY, GTK_RESPONSE_APPLY, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (orient_map_window), GTK_RESPONSE_OK, GTK_RESPONSE_APPLY, GTK_RESPONSE_CANCEL, -1); g_signal_connect (orient_map_window, "response", G_CALLBACK (orient_map_response), orient_map_window); g_signal_connect (orient_map_window, "destroy", G_CALLBACK (gtk_widget_destroyed), &orient_map_window); table1 = gtk_table_new (2, 5, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table1), 6); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (orient_map_window))), table1, TRUE, TRUE, 0); gtk_widget_show (table1); frame = gtk_frame_new (_("Vectors")); gtk_container_set_border_width (GTK_CONTAINER (frame), 2); gtk_table_attach (GTK_TABLE (table1), frame, 0, 1, 0, 1, GTK_EXPAND, GTK_EXPAND, 0, 0); gtk_widget_show (frame); hbox = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (frame), hbox); gtk_widget_show (hbox); ebox = gtk_event_box_new (); gimp_help_set_help_data (ebox, _("The vector-field. " "Left-click to move selected vector, " "Right-click to point it towards mouse, " "Middle-click to add a new vector."), NULL); gtk_box_pack_start (GTK_BOX (hbox), ebox, FALSE, FALSE, 0); tmpw = vector_preview = gimp_preview_area_new (); gtk_widget_set_size_request (tmpw, OMWIDTH, OMHEIGHT); gtk_container_add (GTK_CONTAINER (ebox), tmpw); gtk_widget_show (tmpw); gtk_widget_add_events (ebox, GDK_BUTTON_PRESS_MASK); g_signal_connect (ebox, "button-press-event", G_CALLBACK (map_click_callback), NULL); gtk_widget_show (ebox); vector_preview_brightness_adjust = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 1.0, 1.0); tmpw = gtk_vscale_new (GTK_ADJUSTMENT (vector_preview_brightness_adjust)); gtk_scale_set_draw_value (GTK_SCALE (tmpw), FALSE); gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, FALSE,0); gtk_widget_show (tmpw); g_signal_connect (vector_preview_brightness_adjust, "value-changed", G_CALLBACK (update_vector_prev), NULL); gimp_help_set_help_data (tmpw, _("Adjust the preview's brightness"), NULL); tmpw2 = tmpw = gtk_frame_new (_("Preview")); gtk_container_set_border_width (GTK_CONTAINER (tmpw), 2); gtk_table_attach (GTK_TABLE (table1), tmpw, 1,2, 0,1, GTK_EXPAND, GTK_EXPAND, 0, 0); gtk_widget_show (tmpw); tmpw = orient_map_preview_prev = gimp_preview_area_new (); gtk_widget_set_size_request (tmpw, OMWIDTH, OMHEIGHT);; gtk_container_add (GTK_CONTAINER (tmpw2), tmpw); gtk_widget_show (tmpw); hbox = tmpw = gtk_hbox_new (TRUE,0); gtk_container_set_border_width (GTK_CONTAINER (tmpw), 2); gtk_table_attach_defaults (GTK_TABLE (table1), tmpw, 0,1, 1,2); gtk_widget_show (tmpw); prev_button = tmpw = gtk_button_new_with_mnemonic ("_<<"); gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (prev_click_callback), NULL); gimp_help_set_help_data (tmpw, _("Select previous vector"), NULL); next_button = tmpw = gtk_button_new_with_mnemonic ("_>>"); gtk_box_pack_start (GTK_BOX (hbox),tmpw,FALSE,TRUE,0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (next_click_callback), NULL); gimp_help_set_help_data (tmpw, _("Select next vector"), NULL); add_button = tmpw = gtk_button_new_with_mnemonic ( _("A_dd")); gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (add_click_callback), NULL); gimp_help_set_help_data (tmpw, _("Add new vector"), NULL); kill_button = tmpw = gtk_button_new_with_mnemonic ( _("_Kill")); gtk_box_pack_start (GTK_BOX (hbox), tmpw, FALSE, TRUE, 0); gtk_widget_show (tmpw); g_signal_connect (tmpw, "clicked", G_CALLBACK (delete_click_callback), NULL); gimp_help_set_help_data (tmpw, _("Delete selected vector"), NULL); hbox = gtk_hbox_new (FALSE, 0); gtk_box_set_spacing (GTK_BOX (hbox), 12); gtk_table_attach_defaults (GTK_TABLE (table1), hbox, 0, 2, 2, 3); gtk_widget_show (hbox); vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0); gtk_widget_show (vbox); frame = gimp_int_radio_group_new (TRUE, _("Type"), G_CALLBACK (vector_type_click_callback), &vector_type, 0, _("_Normal"), 0, &vector_types[0], _("Vorte_x"), 1, &vector_types[1], _("Vortex_2"), 2, &vector_types[2], _("Vortex_3"), 3, &vector_types[3], NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); orient_voronoi = tmpw = gtk_check_button_new_with_mnemonic ( _("_Voronoi")); gtk_box_pack_start (GTK_BOX (vbox), tmpw, TRUE, TRUE, 0); gtk_widget_show (tmpw); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tmpw), pcvals.orient_voronoi); g_signal_connect (tmpw, "clicked", G_CALLBACK (angle_offset_adjust_move_callback), NULL); gimp_help_set_help_data (tmpw, _("Voronoi-mode makes only the vector closest to the given point have any influence"), NULL); table2 = gtk_table_new (4, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table2), 4); gtk_box_pack_start (GTK_BOX (hbox), table2, TRUE, TRUE, 0); gtk_widget_show (table2); angle_adjust = gimp_scale_entry_new (GTK_TABLE (table2), 0, 0, _("A_ngle:"), 150, 6, 0.0, 0.0, 360.0, 1.0, 10.0, 1, TRUE, 0, 0, _("Change the angle of the selected vector"), NULL); g_signal_connect (angle_adjust, "value-changed", G_CALLBACK (angle_adjust_move_callback), NULL); angle_offset_adjust = gimp_scale_entry_new (GTK_TABLE (table2), 0, 1, _("Ang_le offset:"), 150, 6, 0.0, 0.0, 360.0, 1.0, 10.0, 1, TRUE, 0, 0, _("Offset all vectors with a given angle"), NULL); g_signal_connect (angle_offset_adjust, "value-changed", G_CALLBACK (angle_offset_adjust_move_callback), NULL); strength_adjust = gimp_scale_entry_new (GTK_TABLE (table2), 0, 2, _("_Strength:"), 150, 6, 1.0, 0.1, 5.0, 0.1, 1.0, 1, TRUE, 0, 0, _("Change the strength of the selected vector"), NULL); g_signal_connect (strength_adjust, "value-changed", G_CALLBACK (strength_adjust_move_callback), NULL); orient_map_str_exp_adjust = gimp_scale_entry_new (GTK_TABLE (table2), 0, 3, _("S_trength exp.:"), 150, 6, 1.0, 0.1, 10.9, 0.1, 1.0, 1, TRUE, 0, 0, _("Change the exponent of the strength"), NULL); g_signal_connect (orient_map_str_exp_adjust, "value-changed", G_CALLBACK (strength_exponent_adjust_move_callback), NULL); gtk_widget_show (orient_map_window); update_vector_prev (); update_orient_map_preview_prev (); }
static void xfburn_preferences_dialog_init (XfburnPreferencesDialog * obj) { GtkBox *box = GTK_BOX (GTK_DIALOG (obj)->vbox); XfburnPreferencesDialogPrivate *priv = XFBURN_PREFERENCES_DIALOG_GET_PRIVATE (obj); GtkWidget *vbox, *vbox2, *vbox3, *hbox; GtkWidget *label; GtkWidget *frame; GtkWidget *scrolled_window; GtkListStore *icon_store, *store; gint x,y; GdkPixbuf *icon = NULL; GtkTreeIter iter; GtkTreeViewColumn *column_name; GtkCellRenderer *cell_icon, *cell_name; GtkWidget *button_close; gint idx; gtk_window_set_title (GTK_WINDOW (obj), _("Preferences")); xfce_titled_dialog_set_subtitle (XFCE_TITLED_DIALOG (obj), _("Tune how Xfburn behaves")); gtk_window_set_default_size (GTK_WINDOW (obj), 775, 400); gtk_window_set_destroy_with_parent (GTK_WINDOW (obj), TRUE); gtk_window_set_icon_name (GTK_WINDOW (obj), GTK_STOCK_PREFERENCES); gtk_dialog_set_has_separator (GTK_DIALOG (obj), FALSE); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (box, hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); scrolled_window = gtk_scrolled_window_new (NULL, NULL); g_object_set (G_OBJECT (scrolled_window), "hscrollbar-policy", GTK_POLICY_NEVER, "shadow-type", GTK_SHADOW_IN, "vscrollbar-policy", GTK_POLICY_NEVER, NULL); gtk_box_pack_start (GTK_BOX (hbox), scrolled_window, FALSE, FALSE, 0); gtk_widget_show (scrolled_window); /* icon bar */ icon_store = gtk_list_store_new (SETTINGS_LIST_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_INT); priv->icon_bar = exo_icon_bar_new_with_model (GTK_TREE_MODEL (icon_store)); exo_icon_bar_set_pixbuf_column (EXO_ICON_BAR (priv->icon_bar), SETTINGS_LIST_PIXBUF_COLUMN); exo_icon_bar_set_text_column (EXO_ICON_BAR (priv->icon_bar), SETTINGS_LIST_TEXT_COLUMN); gtk_container_add (GTK_CONTAINER (scrolled_window), priv->icon_bar); gtk_widget_show (priv->icon_bar); /* notebook */ priv->notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (priv->notebook), BORDER); g_object_set (G_OBJECT (priv->notebook), "show-border", FALSE, "show-tabs", FALSE, NULL); gtk_box_pack_start (GTK_BOX (hbox), priv->notebook, TRUE, TRUE, BORDER); gtk_widget_show (priv->notebook); /* general tab */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), BORDER); idx = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), vbox, NULL); gtk_widget_show (vbox); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); frame = xfce_gtk_frame_box_new_with_content (_("Temporary directory"), vbox2); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, BORDER); gtk_widget_show (frame); priv->chooser_button = gtk_file_chooser_button_new (_("Temporary directory"), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); gtk_box_pack_start (GTK_BOX (vbox2), priv->chooser_button, FALSE, FALSE, BORDER); gtk_widget_show (priv->chooser_button); priv->check_clean_tmpdir = gtk_check_button_new_with_mnemonic (_("_Clean temporary directory on exit")); gtk_box_pack_start (GTK_BOX (vbox2), priv->check_clean_tmpdir, FALSE, FALSE, BORDER); gtk_widget_show (priv->check_clean_tmpdir); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); frame = xfce_gtk_frame_box_new_with_content (_("File browser"), vbox2); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, BORDER); gtk_widget_show (frame); priv->check_show_hidden = gtk_check_button_new_with_mnemonic (_("Show _hidden files")); gtk_box_pack_start (GTK_BOX (vbox2), priv->check_show_hidden, FALSE, FALSE, BORDER); gtk_widget_show (priv->check_show_hidden); g_signal_connect (G_OBJECT (priv->check_show_hidden), "clicked", G_CALLBACK (cb_show_hidden_clicked), NULL); priv->check_show_human_readable = gtk_check_button_new_with_mnemonic (_("Show human_readable filesizes")); gtk_box_pack_start (GTK_BOX (vbox2), priv->check_show_human_readable, FALSE, FALSE, BORDER); gtk_widget_show (priv->check_show_human_readable); icon = gtk_widget_render_icon (GTK_WIDGET (priv->icon_bar), GTK_STOCK_PROPERTIES, GTK_ICON_SIZE_DIALOG, NULL); gtk_list_store_append (icon_store, &iter); gtk_list_store_set (icon_store, &iter, SETTINGS_LIST_PIXBUF_COLUMN, icon, SETTINGS_LIST_TEXT_COLUMN, _("General"), SETTINGS_LIST_INDEX_COLUMN, idx, -1); g_object_unref (G_OBJECT (icon)); /* devices tab */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), BORDER); idx = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), vbox, NULL); gtk_widget_show (vbox); label = gtk_label_new (_("Devices")); gtk_widget_show (label); gtk_notebook_set_tab_label (GTK_NOTEBOOK (priv->notebook), gtk_notebook_get_nth_page (GTK_NOTEBOOK (priv->notebook), 1), label); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); frame = xfce_gtk_frame_box_new_with_content (_("Detected devices"), vbox2); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, BORDER); gtk_widget_show (frame); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN); gtk_widget_show (scrolled_window); gtk_box_pack_start (GTK_BOX (vbox2), scrolled_window, TRUE, TRUE, BORDER); store = gtk_list_store_new (DEVICE_LIST_N_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN); priv->treeview_devices = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), DEVICE_LIST_COLUMN_NAME, GTK_SORT_ASCENDING); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->treeview_devices), TRUE); gtk_widget_show (priv->treeview_devices); gtk_container_add (GTK_CONTAINER (scrolled_window), priv->treeview_devices); g_object_unref (store); /* add columns */ column_name = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column_name, _("Name")); gtk_tree_view_column_set_expand (column_name, TRUE); cell_icon = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column_name, cell_icon, FALSE); gtk_tree_view_column_set_attributes (column_name, cell_icon, "pixbuf", DEVICE_LIST_COLUMN_ICON, NULL); g_object_set (cell_icon, "xalign", 0.0, "ypad", 0, NULL); cell_name = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column_name, cell_name, TRUE); gtk_tree_view_column_set_attributes (column_name, cell_name, "text", DEVICE_LIST_COLUMN_NAME, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview_devices), column_name); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Node"), gtk_cell_renderer_text_new (), "text", DEVICE_LIST_COLUMN_NODE, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write CD-R"), gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_CDR, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write CD-RW"), gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_CDRW, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write DVD-R"), gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_DVDR, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write DVD-RAM"), gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_DVDRAM, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->treeview_devices), -1, _("Write Blu-ray"), gtk_cell_renderer_toggle_new (), "active", DEVICE_LIST_COLUMN_BD, NULL); hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, BORDER); gtk_widget_show (hbox); priv->button_scan = xfce_gtk_button_new_mixed (GTK_STOCK_CDROM, _("Sc_an for devices")); gtk_box_pack_end (GTK_BOX (hbox), priv->button_scan, FALSE, FALSE, BORDER); g_signal_connect (G_OBJECT (priv->button_scan), "clicked", G_CALLBACK (scan_button_clicked_cb), obj); gtk_widget_show (priv->button_scan); gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, &x, &y); icon = gtk_icon_theme_load_icon ( gtk_icon_theme_get_default(), "media-optical", x, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL); if (!icon) icon = gtk_icon_theme_load_icon ( gtk_icon_theme_get_default(), "media-cdrom", x, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL); if (!icon) icon = gtk_icon_theme_load_icon ( gtk_icon_theme_get_default(), GTK_STOCK_CDROM, x, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL); gtk_list_store_append (icon_store, &iter); gtk_list_store_set (icon_store, &iter, SETTINGS_LIST_PIXBUF_COLUMN, icon, SETTINGS_LIST_TEXT_COLUMN, _("Devices"), SETTINGS_LIST_INDEX_COLUMN, idx, -1); if (icon) g_object_unref (G_OBJECT (icon)); exo_mutual_binding_new (G_OBJECT (priv->notebook), "page", G_OBJECT (priv->icon_bar), "active"); /* below the device list */ #if 0 priv->check_empty_speed_list = gtk_check_button_new_with_mnemonic (_("Show warning on _empty speed list")); gtk_box_pack_start (GTK_BOX (vbox2), priv->check_empty_speed_list, FALSE, FALSE, BORDER); gtk_widget_show (priv->check_empty_speed_list); #endif /* fifo */ vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox3); frame = xfce_gtk_frame_box_new_with_content (_("FIFO buffer size (in kb)"), vbox3); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, BORDER); gtk_widget_show (frame); priv->scale_fifo = gtk_hscale_new_with_range (0.0, FIFO_MAX_SIZE, 32.0); gtk_scale_set_value_pos (GTK_SCALE (priv->scale_fifo), GTK_POS_LEFT); gtk_range_set_value (GTK_RANGE (priv->scale_fifo), 0); gtk_box_pack_start (GTK_BOX (vbox3), priv->scale_fifo, FALSE, FALSE, BORDER/2); gtk_widget_show (priv->scale_fifo); /* action buttons */ button_close = gtk_button_new_from_stock ("gtk-close"); gtk_widget_show (button_close); gtk_dialog_add_action_widget (GTK_DIALOG (obj), button_close, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (button_close, GTK_CAN_DEFAULT); gtk_widget_grab_focus (button_close); gtk_widget_grab_default (button_close); g_signal_connect (G_OBJECT (obj), "response", G_CALLBACK (xfburn_preferences_dialog_response_cb), priv); refresh_devices_list (obj); g_object_unref (icon_store); }
void BooleanOptionView::_createItem() { myCheckBox = GTK_CHECK_BUTTON(gtk_check_button_new_with_mnemonic(gtkString(name()).c_str())); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(myCheckBox), ((ZLBooleanOptionEntry&)*myOption).initialState()); g_signal_connect(GTK_WIDGET(myCheckBox), "toggled", G_CALLBACK(_onValueChanged), this); myHolder.attachWidget(*this, GTK_WIDGET(myCheckBox)); }
GtkWidget *create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *label1; GtkWidget *hscaleQual; GtkWidget *checkbuttonUV; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("Mjpeg Codec settings")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); label1 = gtk_label_new (_("Quality")); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (vbox1), label1, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); hscaleAdj=gtk_adjustment_new (0, 0, 100, 0, 0, 0); hscaleQual = gtk_hscale_new (GTK_ADJUSTMENT (hscaleAdj)); gtk_widget_show (hscaleQual); gtk_box_pack_start (GTK_BOX (vbox1), hscaleQual, FALSE, FALSE, 0); gtk_scale_set_digits (GTK_SCALE (hscaleQual), 0); checkbuttonUV = gtk_check_button_new_with_mnemonic (_("Swap U & V")); gtk_widget_show (checkbuttonUV); gtk_box_pack_start (GTK_BOX (vbox1), checkbuttonUV, FALSE, FALSE, 0); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, hscaleQual, "hscaleQual"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonUV, "checkbuttonUV"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
static void gfilter_dialog(GFilterArgs *args, GwyContainer *data, GwyDataField *dfield, GwyDataField *mfield, gint id, GQuark mquark) { GtkWidget *dialog, *table, *vbox, *hbox, *scwin, *hbox2, *label; GtkTreeView *treeview; GtkTreeSelection *selection; GFilterControls controls; gint response, row, i; GwySIUnit *siunit; GwyPixmapLayer *layer; controls.args = args; controls.mask = mfield; controls.in_init = TRUE; controls.computed = FALSE; siunit = gwy_si_unit_new(NULL); for (i = 0; i < NQUANTITIES; i++) { controls.vf[i] = gwy_si_unit_get_format_with_digits(siunit, GWY_SI_UNIT_FORMAT_VFMARKUP, 1.0, 4, NULL); } g_object_unref(siunit); dialog = gtk_dialog_new_with_buttons(_("Filter Grains"), NULL, 0, NULL); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), gwy_stock_like_button_new(_("_Update"), GTK_STOCK_EXECUTE), RESPONSE_PREVIEW); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK, GTK_RESPONSE_OK); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), RESPONSE_PREVIEW, !args->update); gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT); controls.dialog = dialog; hbox = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 4); vbox = gtk_vbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4); controls.mydata = gwy_container_new(); gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield); mfield = gwy_data_field_duplicate(mfield); gwy_container_set_object_by_name(controls.mydata, "/0/mask", mfield); g_object_unref(mfield); gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE, GWY_DATA_ITEM_PALETTE, GWY_DATA_ITEM_MASK_COLOR, GWY_DATA_ITEM_RANGE, GWY_DATA_ITEM_REAL_SQUARE, 0); controls.view = gwy_data_view_new(controls.mydata); layer = gwy_layer_basic_new(); g_object_set(layer, "data-key", "/0/data", "gradient-key", "/0/base/palette", "range-type-key", "/0/base/range-type", "min-max-key", "/0/base", NULL); gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer); layer = gwy_layer_mask_new(); gwy_pixmap_layer_set_data_key(layer, "/0/mask"); gwy_layer_mask_set_color_key(GWY_LAYER_MASK(layer), "/0/mask"); gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls.view), layer); gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE); gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0); controls.update = gtk_check_button_new_with_mnemonic(_("I_nstant updates")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.update), args->update); gtk_box_pack_start(GTK_BOX(vbox), controls.update, FALSE, FALSE, 0); g_signal_connect_swapped(controls.update, "toggled", G_CALLBACK(update_changed), &controls); hbox2 = gtk_hbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic(_("_Mask color:")); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); controls.color_button = gwy_color_button_new(); gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button), TRUE); load_mask_color(controls.color_button, gwy_data_view_get_data(GWY_DATA_VIEW(controls.view))); gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.color_button); gtk_box_pack_start(GTK_BOX(hbox2), controls.color_button, FALSE, FALSE, 0); g_signal_connect(controls.color_button, "clicked", G_CALLBACK(mask_color_changed), &controls); table = gtk_table_new(10, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 4); controls.table = table; row = 0; scwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_table_attach(GTK_TABLE(table), scwin, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); controls.values = gwy_grain_value_tree_view_new(FALSE, "name", "symbol_markup", NULL); treeview = GTK_TREE_VIEW(controls.values); gtk_widget_set_size_request(scwin, -1, 120); gtk_tree_view_set_headers_visible(treeview, FALSE); selection = gtk_tree_view_get_selection(treeview); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); gwy_grain_value_tree_view_set_same_units(treeview, args->units_equal); gwy_grain_value_tree_view_set_expanded_groups(treeview, args->expanded); gtk_container_add(GTK_CONTAINER(scwin), controls.values); row++; hbox2 = gtk_hbox_new(FALSE, 0); for (i = 0; i < NQUANTITIES; i++) { gchar buf[2]; buf[0] = 'A' + i; buf[1] = '\0'; controls.set_as[i] = gtk_button_new_with_label(buf); gtk_box_pack_start(GTK_BOX(hbox2), controls.set_as[i], FALSE, FALSE, 0); g_object_set_data(G_OBJECT(controls.set_as[i]), "id", GUINT_TO_POINTER(i)); g_signal_connect_swapped(controls.set_as[i], "clicked", G_CALLBACK(set_as_clicked), &controls); } gwy_table_attach_hscale(table, row++, _("Set selected as:"), NULL, GTK_OBJECT(hbox2), GWY_HSCALE_WIDGET_NO_EXPAND); controls.logical_op = gwy_enum_combo_box_newl(G_CALLBACK(logical_op_changed), &controls, args->logical, "A", GRAIN_LOGICAL_A, "A ∧ B", GRAIN_LOGICAL_A_AND_B, "A ∨ B", GRAIN_LOGICAL_A_OR_B, "A ∧ B ∧ C", GRAIN_LOGICAL_A_AND_B_AND_C, "A ∨ B ∨ C", GRAIN_LOGICAL_A_OR_B_OR_C, "(A ∧ B) ∨ C", GRAIN_LOGICAL_A_AND_B_OR_C, "(A ∨ B) ∧ C", GRAIN_LOGICAL_A_OR_B_AND_C, NULL); gwy_table_attach_hscale(table, row++, _("Keep grains satisfying:"), NULL, GTK_OBJECT(controls.logical_op), GWY_HSCALE_WIDGET); for (i = 0; i < NQUANTITIES; i++) { gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8); controls.header[i] = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(controls.header[i]), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.header[i], 0, 4, row, row+1, GTK_FILL, 0, 0, 0); row++; /* The values are set properly later. */ controls.lower_label[i] = gtk_label_new(_("Lower threshold:")); gtk_misc_set_alignment(GTK_MISC(controls.lower_label[i]), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.lower_label[i], 0, 1, row, row+1, GTK_FILL, 0, 0, 0); controls.lower[i] = gtk_adjustment_new(0.0, 0.0, 0.0, 1.0, 10.0, 0.0); g_object_set_data(G_OBJECT(controls.lower[i]), "id", GUINT_TO_POINTER(i)); g_signal_connect_swapped(controls.lower[i], "value-changed", G_CALLBACK(threshold_changed), &controls); controls.lower_scale[i] = gtk_hscale_new(GTK_ADJUSTMENT(controls.lower[i])); gtk_scale_set_draw_value(GTK_SCALE(controls.lower_scale[i]), FALSE); gtk_widget_set_size_request(controls.lower_scale[i], GWY_HSCALE_WIDTH, -1); gtk_table_attach(GTK_TABLE(table), controls.lower_scale[i], 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); controls.lower_entry[i] = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(controls.lower_entry[i]), 8); gtk_table_attach(GTK_TABLE(table), controls.lower_entry[i], 2, 3, row, row+1, GTK_FILL, 0, 0, 0); gwy_widget_set_activate_on_unfocus(controls.lower_entry[i], TRUE); g_object_set_data(G_OBJECT(controls.lower_entry[i]), "id", GUINT_TO_POINTER(i)); g_signal_connect_swapped(controls.lower_entry[i], "activate", G_CALLBACK(threshold_activated), &controls); controls.lower_units[i] = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(controls.lower_units[i]), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.lower_units[i], 3, 4, row, row+1, GTK_FILL, 0, 0, 0); row++; controls.upper_label[i] = gtk_label_new(_("Upper threshold:")); gtk_misc_set_alignment(GTK_MISC(controls.upper_label[i]), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.upper_label[i], 0, 1, row, row+1, GTK_FILL, 0, 0, 0); controls.upper[i] = gtk_adjustment_new(0.0, 0.0, 0.0, 1.0, 10.0, 0.0); g_object_set_data(G_OBJECT(controls.upper[i]), "id", GUINT_TO_POINTER(i | IS_UPPER)); g_signal_connect_swapped(controls.upper[i], "value-changed", G_CALLBACK(threshold_changed), &controls); controls.upper_scale[i] = gtk_hscale_new(GTK_ADJUSTMENT(controls.upper[i])); gtk_scale_set_draw_value(GTK_SCALE(controls.upper_scale[i]), FALSE); gtk_widget_set_size_request(controls.upper_scale[i], GWY_HSCALE_WIDTH, -1); gtk_table_attach(GTK_TABLE(table), controls.upper_scale[i], 1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); controls.upper_entry[i] = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(controls.upper_entry[i]), 8); gtk_table_attach(GTK_TABLE(table), controls.upper_entry[i], 2, 3, row, row+1, GTK_FILL, 0, 0, 0); gwy_widget_set_activate_on_unfocus(controls.upper_entry[i], TRUE); g_object_set_data(G_OBJECT(controls.upper_entry[i]), "id", GUINT_TO_POINTER(i | IS_UPPER)); g_signal_connect_swapped(controls.upper_entry[i], "activate", G_CALLBACK(threshold_activated), &controls); controls.upper_units[i] = gtk_label_new(NULL); gtk_misc_set_alignment(GTK_MISC(controls.upper_units[i]), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), controls.upper_units[i], 3, 4, row, row+1, GTK_FILL, 0, 0, 0); row++; } for (i = 0; i < NQUANTITIES; i++) { GwyInventory *inventory; GwyGrainValue *gvalue; inventory = gwy_grain_values(); gvalue = gwy_inventory_get_item(inventory, args->ranges[i].quantity); set_up_quantity(&controls, gvalue, i); } logical_op_changed(GTK_COMBO_BOX(controls.logical_op), &controls); /* finished initializing, allow instant updates */ controls.in_init = FALSE; gfilter_invalidate(&controls); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: args->expanded = gwy_grain_value_tree_view_get_expanded_groups (GTK_TREE_VIEW(controls.values)); for (i = 0; i < NQUANTITIES; i++) gwy_si_unit_value_format_free(controls.vf[i]); gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: g_object_unref(controls.mydata); gfilter_save_args(gwy_app_settings_get(), args); return; break; case GTK_RESPONSE_OK: break; case RESPONSE_PREVIEW: preview(&controls); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); for (i = 0; i < NQUANTITIES; i++) gwy_si_unit_value_format_free(controls.vf[i]); args->expanded = gwy_grain_value_tree_view_get_expanded_groups (GTK_TREE_VIEW(controls.values)); gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE, GWY_DATA_ITEM_MASK_COLOR, 0); gtk_widget_destroy(dialog); gfilter_save_args(gwy_app_settings_get(), args); if (controls.computed) { mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask"); gwy_app_undo_qcheckpointv(data, 1, &mquark); gwy_container_set_object(data, mquark, mfield); g_object_unref(controls.mydata); } else { g_object_unref(controls.mydata); run_noninteractive(args, data, controls.mask, mquark); } gwy_app_channel_log_add_proc(data, id, id); }
static gboolean sobel_dialog (GimpDrawable *drawable) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *preview; GtkWidget *toggle; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Sobel Edge Detection"), PLUG_IN_ROLE, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dialog)); main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); preview = gimp_drawable_preview_new (drawable, NULL); gtk_box_pack_start (GTK_BOX (main_vbox), preview, TRUE, TRUE, 0); gtk_widget_show (preview); g_signal_connect (preview, "invalidated", G_CALLBACK (sobel_preview_update), NULL); toggle = gtk_check_button_new_with_mnemonic (_("Sobel _horizontally")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.horizontal); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &bvals.horizontal); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_check_button_new_with_mnemonic (_("Sobel _vertically")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.vertical); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &bvals.vertical); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); toggle = gtk_check_button_new_with_mnemonic (_("_Keep sign of result " "(one direction only)")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bvals.keep_sign); gtk_box_pack_start (GTK_BOX (main_vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &bvals.keep_sign); g_signal_connect_swapped (toggle, "toggled", G_CALLBACK (gimp_preview_invalidate), preview); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); return run; }
static inline GtkWidget *rc_ui_settings_general_build( RCUiSettingsPrivate *priv) { GtkWidget *general_grid; GtkWidget *frame_label; GtkWidget *general_frame; GtkWidget *general_frame_grid; GtkWidget *audioout_frame; GtkWidget *audioout_frame_grid; GtkListStore *store; GtkCellRenderer *renderer; GtkTreeIter iter; gint audioout_type; general_grid = gtk_grid_new(); priv->gen_autoplay_check_button = gtk_check_button_new_with_mnemonic( _("_Auto play on startup")); priv->gen_loadlast_check_button = gtk_check_button_new_with_mnemonic( _("_Load the last playing position")); priv->gen_mintray_check_button = gtk_check_button_new_with_mnemonic( _("Minimize to _tray")); priv->gen_minclose_check_button = gtk_check_button_new_with_mnemonic( _("Minimize the window if the _close button is clicked")); priv->gen_audioout_label = gtk_label_new(NULL); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); renderer = gtk_cell_renderer_text_new(); priv->gen_audioout_combo_box = gtk_combo_box_new_with_model( GTK_TREE_MODEL(store)); g_object_unref(store); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->gen_audioout_combo_box), renderer, TRUE); gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT( priv->gen_audioout_combo_box), renderer, "text", 0, NULL); gtk_label_set_markup(GTK_LABEL(priv->gen_audioout_label), _("<b>Hint</b>: Change the audio output plug-in will " "<b>stop</b> playing.")); g_object_set(priv->gen_audioout_label, "wrap", TRUE, "wrap-mode", PANGO_WRAP_WORD_CHAR, "hexpand-set", TRUE, "hexpand", TRUE, NULL); general_frame = gtk_frame_new(NULL); frame_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(frame_label), _("<b>General</b>")); g_object_set(general_frame, "label-widget", frame_label, "shadow-type", GTK_SHADOW_NONE, "hexpand-set", TRUE, "hexpand", TRUE, NULL); general_frame_grid = gtk_grid_new(); audioout_frame = gtk_frame_new(NULL); frame_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(frame_label), _("<b>Audio Output Plug-in</b>")); g_object_set(audioout_frame, "label-widget", frame_label, "shadow-type", GTK_SHADOW_NONE, "hexpand-set", TRUE, "hexpand", TRUE, NULL); audioout_frame_grid = gtk_grid_new(); g_object_set(priv->gen_audioout_combo_box, "margin-left", 2, "margin-right", 2, "margin-top", 2, "margin-bottom", 2, "hexpand-set", TRUE, "hexpand", TRUE, NULL); g_object_set(priv->gen_autoplay_check_button, "active", rclib_settings_get_boolean("Player", "AutoPlayWhenStartup", NULL), NULL); g_object_set(priv->gen_loadlast_check_button, "active", rclib_settings_get_boolean("Player", "LoadLastPosition", NULL), NULL); g_object_set(priv->gen_mintray_check_button, "active", rclib_settings_get_boolean("MainUI", "MinimizeToTray", NULL), NULL); g_object_set(priv->gen_minclose_check_button, "active", rclib_settings_get_boolean("MainUI", "MinimizeWhenClose", NULL), NULL); audioout_type = rclib_settings_get_integer("Player", "AudioOutputPluginType", NULL); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, _("Automatic"), 1, RCLIB_CORE_AUDIO_OUTPUT_AUTO, -1); if(audioout_type<RCLIB_CORE_AUDIO_OUTPUT_PULSEAUDIO || audioout_type>RCLIB_CORE_AUDIO_OUTPUT_WAVEFORM) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX( priv->gen_audioout_combo_box), &iter); } gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, _("PulseAudio"), 1, RCLIB_CORE_AUDIO_OUTPUT_PULSEAUDIO, -1); gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, _("ALSA"), 1, RCLIB_CORE_AUDIO_OUTPUT_ALSA, -1); if(audioout_type==RCLIB_CORE_AUDIO_OUTPUT_ALSA) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX( priv->gen_audioout_combo_box), &iter); } gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, _("OSS"), 1, RCLIB_CORE_AUDIO_OUTPUT_OSS, -1); if(audioout_type==RCLIB_CORE_AUDIO_OUTPUT_OSS) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX( priv->gen_audioout_combo_box), &iter); } gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, _("Jack"), 1, RCLIB_CORE_AUDIO_OUTPUT_JACK, -1); if(audioout_type==RCLIB_CORE_AUDIO_OUTPUT_JACK) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX( priv->gen_audioout_combo_box), &iter); } gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, _("Waveform"), 1, RCLIB_CORE_AUDIO_OUTPUT_WAVEFORM, -1); if(audioout_type==RCLIB_CORE_AUDIO_OUTPUT_WAVEFORM) { gtk_combo_box_set_active_iter(GTK_COMBO_BOX( priv->gen_audioout_combo_box), &iter); } gtk_grid_attach(GTK_GRID(general_frame_grid), priv->gen_autoplay_check_button, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(general_frame_grid), priv->gen_loadlast_check_button, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(general_frame_grid), priv->gen_mintray_check_button, 0, 2, 1, 1); gtk_grid_attach(GTK_GRID(general_frame_grid), priv->gen_minclose_check_button, 0, 3, 1, 1); gtk_container_add(GTK_CONTAINER(general_frame), general_frame_grid); gtk_grid_attach(GTK_GRID(audioout_frame_grid), priv->gen_audioout_combo_box, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(audioout_frame_grid), priv->gen_audioout_label, 0, 1, 1, 1); gtk_container_add(GTK_CONTAINER(audioout_frame), audioout_frame_grid); gtk_grid_attach(GTK_GRID(general_grid), audioout_frame, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(general_grid), general_frame, 0, 1, 1, 1); g_signal_connect(priv->gen_autoplay_check_button, "toggled", G_CALLBACK(rc_ui_settings_gen_autoplay_toggled), NULL); g_signal_connect(priv->gen_loadlast_check_button, "toggled", G_CALLBACK(rc_ui_settings_gen_loadlast_toggled), NULL); g_signal_connect(priv->gen_mintray_check_button, "toggled", G_CALLBACK(rc_ui_settings_gen_mintray_toggled), NULL); g_signal_connect(priv->gen_minclose_check_button, "toggled", G_CALLBACK(rc_ui_settings_gen_minclose_toggled), NULL); g_signal_connect(priv->gen_audioout_combo_box, "changed", G_CALLBACK(rc_ui_settings_gen_audioout_changed), NULL); return general_grid; }
static void prof_dialog(ProfArgs *args, GwyContainer *data, GwyDataField *dfield, gint id) { GtkWidget *hbox, *hbox2, *vbox, *label; GwyDataChooser *chooser; GtkTable *table; GtkDialog *dialog; GwyGraph *graph; GwyGraphArea *area; ProfControls controls; gint response; gint row; controls.args = args; controls.psdffield = prof_psdf(dfield, args); controls.modfield = prof_sqrt(controls.psdffield); controls.hx = gwy_data_field_get_xmeasure(dfield)/(2*G_PI); controls.hy = gwy_data_field_get_xmeasure(dfield)/(2*G_PI); controls.dialog = gtk_dialog_new_with_buttons(_("Radial PSDF Section"), NULL, 0, GTK_STOCK_CLEAR, RESPONSE_CLEAR, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); dialog = GTK_DIALOG(controls.dialog); gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK); gtk_dialog_set_response_sensitive(dialog, GTK_RESPONSE_OK, FALSE); gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT); hbox = gtk_hbox_new(FALSE, 2); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 4); controls.mydata = gwy_container_new(); gwy_container_set_object_by_name(controls.mydata, "/0/data", controls.modfield); g_object_unref(controls.modfield); gwy_container_set_string_by_name(controls.mydata, "/0/base/palette", g_strdup("DFit")); gwy_container_set_enum_by_name(controls.mydata, "/0/base/range-type", GWY_LAYER_BASIC_RANGE_AUTO); gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE, GWY_DATA_ITEM_REAL_SQUARE, 0); controls.view = create_preview(controls.mydata, 0, PREVIEW_SIZE, FALSE); controls.selection = create_vector_layer(GWY_DATA_VIEW(controls.view), 0, "Point", TRUE); gwy_selection_set_max_objects(controls.selection, NLINES); g_object_set(gwy_data_view_get_top_layer(GWY_DATA_VIEW(controls.view)), "draw-as-vector", TRUE, NULL); g_signal_connect_swapped(controls.selection, "changed", G_CALLBACK(prof_selection_changed), &controls); gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4); vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 4); controls.gmodel = gwy_graph_model_new(); g_object_set(controls.gmodel, "title", _("PSDF Section"), "axis-label-bottom", "k", "axis-label-left", "W", NULL); init_graph_model_units(controls.gmodel, controls.psdffield); controls.line = gwy_data_line_new(1, 1.0, FALSE); controls.graph = gwy_graph_new(controls.gmodel); graph = GWY_GRAPH(controls.graph); gtk_widget_set_size_request(controls.graph, GRAPH_WIDTH, -1); gwy_graph_set_axis_visible(graph, GTK_POS_LEFT, FALSE); gwy_graph_set_axis_visible(graph, GTK_POS_RIGHT, FALSE); gwy_graph_set_axis_visible(graph, GTK_POS_TOP, FALSE); gwy_graph_set_axis_visible(graph, GTK_POS_BOTTOM, FALSE); gwy_graph_enable_user_input(graph, FALSE); area = GWY_GRAPH_AREA(gwy_graph_get_area(graph)); gwy_graph_area_enable_user_input(area, FALSE); gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 0); table = GTK_TABLE(gtk_table_new(4, 4, FALSE)); gtk_table_set_row_spacings(table, 2); gtk_table_set_col_spacings(table, 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, FALSE, 0); row = 0; controls.resolution = gtk_adjustment_new(controls.args->resolution, MIN_RESOLUTION, MAX_RESOLUTION, 1, 10, 0); gwy_table_attach_hscale(GTK_WIDGET(table), row, _("_Fix res.:"), NULL, controls.resolution, GWY_HSCALE_CHECK | GWY_HSCALE_SQRT); g_signal_connect_swapped(controls.resolution, "value-changed", G_CALLBACK(prof_resolution_changed), &controls); controls.fixres = gwy_table_hscale_get_check(controls.resolution); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.fixres), controls.args->fixres); g_signal_connect_swapped(controls.fixres, "toggled", G_CALLBACK(prof_fixres_changed), &controls); gwy_table_hscale_set_sensitive(controls.resolution, controls.args->fixres); row++; controls.separate = gtk_check_button_new_with_mnemonic(_("_Separate curves")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.separate), args->separate); gtk_table_attach(table, controls.separate, 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_signal_connect_swapped(controls.separate, "toggled", G_CALLBACK(prof_separate_changed), &controls); row++; hbox2 = gtk_hbox_new(FALSE, 6); gtk_table_attach(table, hbox2, 0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); label = gtk_label_new_with_mnemonic(_("_Interpolation type:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); controls.interpolation = gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1, G_CALLBACK(prof_interpolation_changed), &controls, controls.args->interpolation, TRUE); gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.interpolation); gtk_box_pack_end(GTK_BOX(hbox2), controls.interpolation, FALSE, FALSE, 0); row++; controls.target_hbox = hbox2 = gtk_hbox_new(FALSE, 6); gtk_widget_set_sensitive(hbox2, !args->separate); gtk_table_attach(GTK_TABLE(table), hbox2, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); label = gtk_label_new_with_mnemonic(_("Target _graph:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0); controls.target_graph = gwy_data_chooser_new_graphs(); chooser = GWY_DATA_CHOOSER(controls.target_graph); gwy_data_chooser_set_none(chooser, _("New graph")); gwy_data_chooser_set_active(chooser, NULL, -1); gwy_data_chooser_set_filter(chooser, filter_target_graphs, &controls, NULL); gwy_data_chooser_set_active_id(chooser, &args->target_graph); gwy_data_chooser_get_active_id(chooser, &args->target_graph); gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.target_graph); gtk_box_pack_end(GTK_BOX(hbox2), controls.target_graph, FALSE, FALSE, 0); g_signal_connect_swapped(controls.target_graph, "changed", G_CALLBACK(target_graph_changed), &controls); row++; gtk_widget_show_all(controls.dialog); do { response = gtk_dialog_run(dialog); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(controls.dialog); case GTK_RESPONSE_NONE: goto finalize; break; case GTK_RESPONSE_OK: break; case RESPONSE_CLEAR: gwy_selection_clear(controls.selection); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(controls.dialog); prof_execute(&controls, data); finalize: g_object_unref(controls.psdffield); g_object_unref(controls.mydata); g_object_unref(controls.gmodel); g_object_unref(controls.line); }
static inline GtkWidget *rc_ui_settings_playlist_build( RCUiSettingsPrivate *priv) { GtkWidget *playlist_grid; GtkWidget *frame_label; GtkWidget *metadata_frame; GtkWidget *metadata_frame_grid; GtkWidget *metadata_id3enc_label; GtkWidget *metadata_lrcenc_label; GtkWidget *legacy_frame; GtkWidget *legacy_frame_grid; GtkWidget *legacy_button_box; gchar *string; playlist_grid = gtk_grid_new(); priv->pl_autoenc_check_button = gtk_check_button_new_with_mnemonic( _("_Auto encoding detect (use system language settings)")); priv->pl_id3enc_entry = gtk_entry_new(); priv->pl_lrcenc_entry = gtk_entry_new(); priv->pl_ldlgc_button = gtk_button_new_with_mnemonic( _("Load playlist from _legacy version")); metadata_id3enc_label = gtk_label_new( _("ID3 Tag fallback character encodings")); metadata_lrcenc_label = gtk_label_new( _("Lyric text fallback character encodings")); metadata_frame = gtk_frame_new(NULL); frame_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(frame_label), _("<b>Metadata</b>")); g_object_set(metadata_frame, "label-widget", frame_label, "shadow-type", GTK_SHADOW_NONE, "hexpand-set", TRUE, "hexpand", TRUE, NULL); metadata_frame_grid = gtk_grid_new(); g_object_set(priv->pl_id3enc_entry, "margin-left", 2, "margin-right", 2, "margin-top", 2, "margin-bottom", 2, "hexpand-set", TRUE, "hexpand", TRUE, NULL); g_object_set(priv->pl_lrcenc_entry, "margin-left", 2, "margin-right", 2, "margin-top", 2, "margin-bottom", 2, "hexpand-set", TRUE, "hexpand", TRUE, NULL); legacy_frame = gtk_frame_new(NULL); frame_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(frame_label), _("<b>Legacy Support</b>")); g_object_set(legacy_frame, "label-widget", frame_label, "shadow-type", GTK_SHADOW_NONE, "hexpand-set", TRUE, "hexpand", TRUE, NULL); legacy_frame_grid = gtk_grid_new(); legacy_button_box = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL); g_object_set(legacy_button_box, "margin-left", 2, "margin-right", 2, "margin-top", 2, "margin-bottom", 2, "hexpand-set", TRUE, "hexpand", TRUE, NULL, "layout-style", GTK_BUTTONBOX_CENTER, "spacing", 5, NULL); if(rclib_settings_get_boolean("Metadata", "AutoDetectEncoding", NULL)) { g_object_set(priv->pl_autoenc_check_button, "active", TRUE, NULL); g_object_set(priv->pl_id3enc_entry, "sensitive", FALSE, NULL); g_object_set(priv->pl_lrcenc_entry, "sensitive", FALSE, NULL); } string = rclib_settings_get_string("Metadata", "ID3Encoding", NULL); if(string!=NULL) gtk_entry_set_text(GTK_ENTRY(priv->pl_id3enc_entry), string); g_free(string); string = rclib_settings_get_string("Metadata", "LyricEncoding", NULL); if(string!=NULL) gtk_entry_set_text(GTK_ENTRY(priv->pl_lrcenc_entry), string); g_free(string); gtk_grid_attach(GTK_GRID(metadata_frame_grid), priv->pl_autoenc_check_button, 0, 0, 2, 1); gtk_grid_attach(GTK_GRID(metadata_frame_grid), metadata_id3enc_label, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(metadata_frame_grid), priv->pl_id3enc_entry, 1, 1, 1, 1); gtk_grid_attach(GTK_GRID(metadata_frame_grid), metadata_lrcenc_label, 0, 2, 1, 1); gtk_grid_attach(GTK_GRID(metadata_frame_grid), priv->pl_lrcenc_entry, 1, 2, 1, 1); gtk_container_add(GTK_CONTAINER(metadata_frame), metadata_frame_grid); gtk_box_pack_start(GTK_BOX(legacy_button_box), priv->pl_ldlgc_button, FALSE, FALSE, 2); gtk_grid_attach(GTK_GRID(legacy_frame_grid), legacy_button_box, 0, 0, 2, 1); gtk_container_add(GTK_CONTAINER(legacy_frame), legacy_frame_grid); gtk_grid_attach(GTK_GRID(playlist_grid), metadata_frame, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(playlist_grid), legacy_frame, 0, 1, 1, 1); g_signal_connect(priv->pl_autoenc_check_button, "toggled", G_CALLBACK(rc_ui_settings_pl_autoenc_toggled), NULL); g_signal_connect(priv->pl_id3enc_entry, "changed", G_CALLBACK(rc_ui_settings_pl_id3enc_changed), NULL); g_signal_connect(priv->pl_lrcenc_entry, "changed", G_CALLBACK(rc_ui_settings_pl_lrcenc_changed), NULL); g_signal_connect(priv->pl_ldlgc_button, "clicked", G_CALLBACK(rc_ui_dialog_show_load_legacy), NULL); return playlist_grid; }
GtkWidget* gtr_torrent_options_dialog_new( GtkWindow * parent, TrCore * core, tr_ctor * ctor ) { guint row; guint col; const char * str; GtkWidget * w; GtkWidget * d; GtkWidget * t; GtkWidget * l; GtkWidget * source_chooser; struct OpenData * data; bool flag; GSList * list; GSList * walk; /* make the dialog */ d = gtk_dialog_new_with_buttons( _( "Torrent Options" ), parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL ); gtk_dialog_set_default_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT ); gtk_dialog_set_alternative_button_order( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT, GTK_RESPONSE_CANCEL, -1 ); if( tr_ctorGetDownloadDir( ctor, TR_FORCE, &str ) ) g_assert_not_reached( ); g_assert( str ); data = g_new0( struct OpenData, 1 ); data->core = core; data->ctor = ctor; data->filename = g_strdup( tr_ctorGetSourceFile( ctor ) ); data->downloadDir = g_strdup( str ); data->file_list = gtr_file_list_new( core, 0 ); str = _( "Mo_ve .torrent file to the trash" ); data->trash_check = gtk_check_button_new_with_mnemonic( str ); str = _( "_Start when added" ); data->run_check = gtk_check_button_new_with_mnemonic( str ); w = data->priority_combo = gtr_priority_combo_new( ); gtr_priority_combo_set_value( GTK_COMBO_BOX( w ), TR_PRI_NORMAL ); g_signal_connect( G_OBJECT( d ), "response", G_CALLBACK( addResponseCB ), data ); t = gtk_table_new( 6, 2, FALSE ); gtk_container_set_border_width( GTK_CONTAINER( t ), GUI_PAD_BIG ); gtk_table_set_row_spacings( GTK_TABLE( t ), GUI_PAD ); gtk_table_set_col_spacings( GTK_TABLE( t ), GUI_PAD_BIG ); row = col = 0; l = gtk_label_new_with_mnemonic( _( "_Torrent file:" ) ); gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 ); ++col; w = gtk_file_chooser_button_new( _( "Select Source File" ), GTK_FILE_CHOOSER_ACTION_OPEN ); source_chooser = w; gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w ); addTorrentFilters( GTK_FILE_CHOOSER( w ) ); g_signal_connect( w, "selection-changed", G_CALLBACK( sourceChanged ), data ); ++row; col = 0; l = gtk_label_new_with_mnemonic( _( "_Destination folder:" ) ); gtk_misc_set_alignment( GTK_MISC( l ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), l, col, col + 1, row, row + 1, GTK_FILL, 0, 0, 0 ); ++col; w = gtk_file_chooser_button_new( _( "Select Destination Folder" ), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ); if( !gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), data->downloadDir ) ) g_warning( "couldn't select '%s'", data->downloadDir ); list = get_recent_destinations( ); for( walk = list; walk; walk = walk->next ) gtk_file_chooser_add_shortcut_folder( GTK_FILE_CHOOSER( w ), walk->data, NULL ); g_slist_free( list ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( l ), w ); g_signal_connect( w, "selection-changed", G_CALLBACK( downloadDirChanged ), data ); ++row; col = 0; w = data->file_list; gtk_widget_set_size_request ( w, 466u, 300u ); gtk_table_attach_defaults( GTK_TABLE( t ), w, col, col + 2, row, row + 1 ); ++row; col = 0; w = gtk_label_new_with_mnemonic( _( "Torrent _priority:" ) ); gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.5f ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); ++col; gtk_table_attach( GTK_TABLE( t ), data->priority_combo, col, col + 1, row, row + 1, ~0, 0, 0, 0 ); gtk_label_set_mnemonic_widget( GTK_LABEL( w ), data->priority_combo ); ++row; col = 0; w = data->run_check; if( tr_ctorGetPaused( ctor, TR_FORCE, &flag ) ) g_assert_not_reached( ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), !flag ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 ); ++row; col = 0; w = data->trash_check; if( tr_ctorGetDeleteSource( ctor, &flag ) ) g_assert_not_reached( ); gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( w ), flag ); gtk_table_attach( GTK_TABLE( t ), w, col, col + 2, row, row + 1, GTK_FILL, 0, 0, 0 ); /* trigger sourceChanged, either directly or indirectly, * so that it creates the tor/gtor objects */ w = source_chooser; if( data->filename ) gtk_file_chooser_set_filename( GTK_FILE_CHOOSER( w ), data->filename ); else sourceChanged( GTK_FILE_CHOOSER_BUTTON( w ), data ); gtr_dialog_set_content( GTK_DIALOG( d ), t ); w = gtk_dialog_get_widget_for_response( GTK_DIALOG( d ), GTK_RESPONSE_ACCEPT ); gtk_widget_grab_focus( w ); return d; }
static inline GtkWidget *rc_ui_settings_interface_build( RCUiSettingsPrivate *priv) { GtkWidget *interface_grid; GtkWidget *frame_label; GtkWidget *mainwin_frame; GtkWidget *mainwin_frame_grid; GtkWidget *listview_frame; GtkWidget *listview_frame_grid; GtkWidget *titleformat_label; GtkWidget *note_label; GtkWidget *showcolumn_frame_grid; guint column_flags; interface_grid = gtk_grid_new(); priv->if_hidecovimg_check_button = gtk_check_button_new_with_mnemonic( _("Hide cover _image")); priv->if_hidelrc_check_button = gtk_check_button_new_with_mnemonic( _("Hide _lyric labels")); priv->if_hidespr_check_button = gtk_check_button_new_with_mnemonic( _("Hide _spectrum show")); priv->if_multicolumn_check_button = gtk_check_button_new_with_mnemonic( _("Show _metadata in multi-columns")); priv->if_titleformat_entry = gtk_entry_new(); priv->if_showarcolumn_check_button = gtk_check_button_new_with_mnemonic( _("Artist")); priv->if_showalcolumn_check_button = gtk_check_button_new_with_mnemonic( _("Album")); priv->if_showtrcolumn_check_button = gtk_check_button_new_with_mnemonic( _("Track")); priv->if_showyecolumn_check_button = gtk_check_button_new_with_mnemonic( _("Year")); priv->if_showftcolumn_check_button = gtk_check_button_new_with_mnemonic( _("Format")); priv->if_showrtcolumn_check_button = gtk_check_button_new_with_mnemonic( _("Rating")); priv->if_showgecolumn_check_button = gtk_check_button_new_with_mnemonic( _("Genre")); priv->if_titleformat_grid = gtk_grid_new(); showcolumn_frame_grid = gtk_grid_new(); priv->if_showcolumn_frame = gtk_frame_new(NULL); frame_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(frame_label), _("<b>Playlist Visible Columns</b>")); g_object_set(priv->if_showcolumn_frame, "label-widget", frame_label, "hexpand-set", TRUE, "hexpand", TRUE, NULL); titleformat_label = gtk_label_new(_("Title column format: ")); note_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(note_label), _("<b>Hint</b>: Use " "<i>%TITLE</i> as title string, <i>%ARTIST</i> as artist string, " "<i>%ALBUM</i> as album string, somehow <i>%TITLE</i> must be " "included in the format string.")); g_object_set(note_label, "wrap", TRUE, "wrap-mode", PANGO_WRAP_WORD_CHAR, "hexpand-set", TRUE, "hexpand", TRUE, NULL); g_object_set(priv->if_titleformat_entry, "hexpand-set", TRUE, "hexpand", TRUE, NULL); g_object_set(priv->if_titleformat_grid, "hexpand-set", TRUE, "hexpand", TRUE, NULL); g_object_set(priv->if_showcolumn_frame, "hexpand-set", TRUE, "hexpand", TRUE, NULL); gtk_grid_attach(GTK_GRID(priv->if_titleformat_grid), titleformat_label, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(priv->if_titleformat_grid), priv->if_titleformat_entry, 1, 0, 1, 1); gtk_grid_attach(GTK_GRID(priv->if_titleformat_grid), note_label, 0, 1, 2, 1); gtk_grid_attach(GTK_GRID(showcolumn_frame_grid), priv->if_showarcolumn_check_button, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(showcolumn_frame_grid), priv->if_showalcolumn_check_button, 1, 0, 1, 1); gtk_grid_attach(GTK_GRID(showcolumn_frame_grid), priv->if_showtrcolumn_check_button, 2, 0, 1, 1); gtk_grid_attach(GTK_GRID(showcolumn_frame_grid), priv->if_showgecolumn_check_button, 3, 0, 1, 1); gtk_grid_attach(GTK_GRID(showcolumn_frame_grid), priv->if_showyecolumn_check_button, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(showcolumn_frame_grid), priv->if_showftcolumn_check_button, 1, 1, 1, 1); gtk_grid_attach(GTK_GRID(showcolumn_frame_grid), priv->if_showrtcolumn_check_button, 2, 1, 1, 1); gtk_container_add(GTK_CONTAINER(priv->if_showcolumn_frame), showcolumn_frame_grid); gtk_widget_show_all(priv->if_titleformat_grid); gtk_widget_show_all(priv->if_showcolumn_frame); gtk_widget_set_no_show_all(priv->if_titleformat_grid, TRUE); gtk_widget_set_no_show_all(priv->if_showcolumn_frame, TRUE); mainwin_frame = gtk_frame_new(NULL); frame_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(frame_label), _("<b>Main Window</b>")); g_object_set(mainwin_frame, "label-widget", frame_label, "shadow-type", GTK_SHADOW_NONE, "hexpand-set", TRUE, "hexpand", TRUE, NULL); mainwin_frame_grid = gtk_grid_new(); listview_frame = gtk_frame_new(NULL); frame_label = gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(frame_label), _("<b>List Views</b>")); g_object_set(listview_frame, "label-widget", frame_label, "shadow-type", GTK_SHADOW_NONE, "hexpand-set", TRUE, "hexpand", TRUE, NULL); listview_frame_grid = gtk_grid_new(); g_object_set(priv->if_hidecovimg_check_button, "active", rclib_settings_get_boolean("MainUI", "HideCoverImage", NULL), NULL); g_object_set(priv->if_hidelrc_check_button, "active", rclib_settings_get_boolean("MainUI", "HideLyricLabels", NULL), NULL); g_object_set(priv->if_hidespr_check_button, "active", rclib_settings_get_boolean("MainUI", "HideSpectrumWidget", NULL), NULL); g_object_set(priv->if_titleformat_entry, "text", rc_ui_list_model_get_playlist_title_format(), NULL); column_flags = rc_ui_listview_playlist_get_enabled_columns(); g_object_set(priv->if_showarcolumn_check_button, "active", column_flags & RC_UI_LISTVIEW_PLAYLIST_COLUMN_ARTIST ? TRUE: FALSE, NULL); g_object_set(priv->if_showalcolumn_check_button, "active", column_flags & RC_UI_LISTVIEW_PLAYLIST_COLUMN_ALBUM ? TRUE: FALSE, NULL); g_object_set(priv->if_showtrcolumn_check_button, "active", column_flags & RC_UI_LISTVIEW_PLAYLIST_COLUMN_TRACK ? TRUE: FALSE, NULL); g_object_set(priv->if_showyecolumn_check_button, "active", column_flags & RC_UI_LISTVIEW_PLAYLIST_COLUMN_YEAR ? TRUE: FALSE, NULL); g_object_set(priv->if_showftcolumn_check_button, "active", column_flags & RC_UI_LISTVIEW_PLAYLIST_COLUMN_FTYPE ? TRUE: FALSE, NULL); g_object_set(priv->if_showrtcolumn_check_button, "active", column_flags & RC_UI_LISTVIEW_PLAYLIST_COLUMN_RATING ? TRUE: FALSE, NULL); g_object_set(priv->if_showgecolumn_check_button, "active", column_flags & RC_UI_LISTVIEW_PLAYLIST_COLUMN_GENRE ? TRUE: FALSE, NULL); if(rc_ui_listview_playlist_get_column_display_mode()) { g_object_set(priv->if_multicolumn_check_button, "active", TRUE, NULL); g_object_set(priv->if_titleformat_grid, "visible", FALSE, NULL); } else { g_object_set(priv->if_showcolumn_frame, "visible", FALSE, NULL); } gtk_grid_attach(GTK_GRID(mainwin_frame_grid), priv->if_hidecovimg_check_button, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(mainwin_frame_grid), priv->if_hidelrc_check_button, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(mainwin_frame_grid), priv->if_hidespr_check_button, 0, 2, 1, 1); gtk_grid_attach(GTK_GRID(listview_frame_grid), priv->if_multicolumn_check_button, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(listview_frame_grid), priv->if_titleformat_grid, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(listview_frame_grid), priv->if_showcolumn_frame, 0, 2, 1, 1); gtk_container_add(GTK_CONTAINER(mainwin_frame), mainwin_frame_grid); gtk_container_add(GTK_CONTAINER(listview_frame), listview_frame_grid); gtk_grid_attach(GTK_GRID(interface_grid), mainwin_frame, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(interface_grid), listview_frame, 0, 1, 1, 1); g_signal_connect(priv->if_hidecovimg_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_hidecovimg_toggled), NULL); g_signal_connect(priv->if_hidelrc_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_hidelrc_toggled), NULL); g_signal_connect(priv->if_hidespr_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_hidespr_toggled), NULL); g_signal_connect(priv->if_multicolumn_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_multicolumn_toggled), priv); g_signal_connect(priv->if_titleformat_entry, "changed", G_CALLBACK(rc_ui_settings_if_titleformat_changed), priv); g_signal_connect(priv->if_showarcolumn_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_showcolumn_toggled), priv); g_signal_connect(priv->if_showalcolumn_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_showcolumn_toggled), priv); g_signal_connect(priv->if_showtrcolumn_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_showcolumn_toggled), priv); g_signal_connect(priv->if_showyecolumn_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_showcolumn_toggled), priv); g_signal_connect(priv->if_showftcolumn_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_showcolumn_toggled), priv); g_signal_connect(priv->if_showrtcolumn_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_showcolumn_toggled), priv); g_signal_connect(priv->if_showgecolumn_check_button, "toggled", G_CALLBACK(rc_ui_settings_if_showcolumn_toggled), priv); return interface_grid; }
static void gwy_app_file_chooser_add_type_list(GwyAppFileChooser *chooser) { GtkWidget *vbox, *scwin; GtkTreeView *treeview; GtkFileChooserAction action; GtkRequisition req; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkListStore *store; GtkTreeIter iter; gboolean expanded = FALSE; gboolean filter = FALSE; gchar *key; g_object_get(chooser, "action", &action, NULL); key = g_strconcat(chooser->prefix, "/type", NULL); chooser->type_key = g_quark_from_string(key); g_free(key); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); gtk_list_store_append(store, &iter); switch (action) { case GTK_FILE_CHOOSER_ACTION_SAVE: gtk_list_store_set(store, &iter, COLUMN_FILETYPE, "", COLUMN_LABEL, _("Automatic by extension"), -1); gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_SAVE); gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_EXPORT); break; case GTK_FILE_CHOOSER_ACTION_OPEN: gtk_list_store_set(store, &iter, COLUMN_FILETYPE, "", COLUMN_LABEL, _("Automatically detected"), -1); gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_LOAD); break; default: g_assert_not_reached(); break; } chooser->expander = gtk_expander_new(NULL); gtk_expander_set_use_underline(GTK_EXPANDER(chooser->expander), TRUE); gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(chooser), chooser->expander); key = g_strconcat(chooser->prefix, "/expanded", NULL); gwy_container_gis_boolean_by_name(gwy_app_settings_get(), key, &expanded); g_free(key); gtk_expander_set_expanded(GTK_EXPANDER(chooser->expander), expanded); g_signal_connect_swapped(chooser->expander, "notify::expanded", G_CALLBACK(gwy_app_file_chooser_expanded), chooser); vbox = gtk_vbox_new(FALSE, 4); gtk_container_add(GTK_CONTAINER(chooser->expander), vbox); scwin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), scwin, TRUE, TRUE, 0); chooser->type_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); treeview = GTK_TREE_VIEW(chooser->type_list); g_object_unref(store); gtk_tree_view_set_headers_visible(treeview, FALSE); gtk_container_add(GTK_CONTAINER(scwin), chooser->type_list); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(treeview, column); renderer = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(column), renderer, "text", COLUMN_LABEL); selection = gtk_tree_view_get_selection(treeview); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); g_signal_connect_swapped(selection, "changed", G_CALLBACK(gwy_app_file_chooser_type_changed), chooser); if (action == GTK_FILE_CHOOSER_ACTION_OPEN) { chooser->filter_enable = gtk_check_button_new_with_mnemonic(_("Show only loadable " "files of selected type")); key = g_strconcat(chooser->prefix, "/filter", NULL); gwy_container_gis_boolean_by_name(gwy_app_settings_get(), key, &filter); g_free(key); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chooser->filter_enable), filter); gtk_box_pack_start(GTK_BOX(vbox), chooser->filter_enable, FALSE, FALSE, 0); g_signal_connect_swapped(chooser->filter_enable, "toggled", G_CALLBACK(gwy_app_file_chooser_filter_toggled), chooser); gwy_app_file_chooser_filter_toggled(chooser, GTK_TOGGLE_BUTTON(chooser->filter_enable)); } /* Give it some reasonable size. FIXME: hack. */ gtk_widget_show_all(vbox); gtk_widget_size_request(scwin, &req); gtk_widget_set_size_request(scwin, -1, 3*req.height + 20); gwy_app_file_chooser_select_type(chooser); gwy_app_file_chooser_type_changed(chooser, selection); }
gint sinus_dialog (void) { GtkWidget *dlg; GtkWidget *main_hbox; GtkWidget *preview; GtkWidget *notebook; GtkWidget *page; GtkWidget *frame; GtkWidget *label; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *hbox; GtkWidget *table; GtkWidget *toggle; GtkWidget *push_col1 = NULL; GtkWidget *push_col2 = NULL; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, TRUE); /* Create Main window with a vbox */ /* ============================== */ dlg = gimp_dialog_new (_("Sinus"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dlg), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gimp_window_set_transient (GTK_WINDOW (dlg)); main_hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* Create preview */ /* ============== */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); preview = mw_preview_new (vbox, thePreview); /* Create the notebook */ /* =================== */ notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP); gtk_box_pack_start (GTK_BOX (main_hbox), notebook, FALSE, FALSE, 0); gtk_widget_show (notebook); /* Create the drawing settings frame */ /* ================================= */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); frame = gimp_frame_new (_("Drawing Settings")); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (3, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER(frame), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_X scale:"), 140, 8, svals.scalex, 0.0001, 100.0, 0.0001, 5, 4, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.scalex); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("_Y scale:"), 140, 8, svals.scaley, 0.0001, 100.0, 0.0001, 5, 4, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.scaley); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, _("Co_mplexity:"), 140, 8, svals.cmplx, 0.0, 15.0, 0.01, 5, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.cmplx); gtk_widget_show (table); frame= gimp_frame_new (_("Calculation Settings")); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); table = gtk_table_new (3, 1, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0); hbox = gimp_random_seed_new (&svals.seed, &svals.random_seed); label = gimp_table_attach_aligned (GTK_TABLE (table), 0, 0, _("R_andom seed:"), 1.0, 0.5, hbox, 1, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), GIMP_RANDOM_SEED_SPINBUTTON (hbox)); g_signal_connect (GIMP_RANDOM_SEED_SPINBUTTON_ADJ (hbox), "value-changed", G_CALLBACK (sinus_random_update), NULL); gtk_widget_show (table); toggle = gtk_check_button_new_with_mnemonic (_("_Force tiling?")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), svals.tiling); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (sinus_toggle_button_update), &svals.tiling); vbox2 = gimp_int_radio_group_new (FALSE, NULL, G_CALLBACK (sinus_radio_button_update), &svals.perturbation, svals.perturbation, _("_Ideal"), IDEAL, NULL, _("_Distorted"), PERTURBED, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); gtk_widget_show (vbox2); label = gtk_label_new_with_mnemonic (_("_Settings")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); /* Color settings dialog: */ /* ====================== */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); if (drawable_is_grayscale) { frame = gimp_frame_new (_("Colors")); gtk_box_pack_start(GTK_BOX(page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /*if in grey scale, the colors are necessarily black and white */ label = gtk_label_new (_("The colors are white and black.")); gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5); gtk_container_add (GTK_CONTAINER (vbox), label); gtk_widget_show (label); } else { frame = gimp_int_radio_group_new (TRUE, _("Colors"), G_CALLBACK (sinus_radio_button_update), &svals.colors, svals.colors, _("Bl_ack & white"), B_W, NULL, _("_Foreground & background"), USE_FG_BG, NULL, _("C_hoose here:"), USE_COLORS, NULL, NULL); gtk_box_pack_start(GTK_BOX(page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = GTK_BIN (frame)->child; hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); push_col1 = gimp_color_button_new (_("First color"), 32, 32, &svals.col1, GIMP_COLOR_AREA_SMALL_CHECKS); gtk_box_pack_start (GTK_BOX (hbox), push_col1, FALSE, FALSE, 0); gtk_widget_show (push_col1); g_signal_connect (push_col1, "color-changed", G_CALLBACK (gimp_color_button_get_color), &svals.col1); push_col2 = gimp_color_button_new (_("Second color"), 32, 32, &svals.col2, GIMP_COLOR_AREA_SMALL_CHECKS); gtk_box_pack_start (GTK_BOX (hbox), push_col2, FALSE, FALSE, 0); gtk_widget_show (push_col2); g_signal_connect (push_col2, "color-changed", G_CALLBACK (gimp_color_button_get_color), &svals.col2); gtk_widget_show (hbox); } frame = gimp_frame_new (_("Alpha Channels")); gtk_box_pack_start (GTK_BOX (page), frame, FALSE, FALSE, 0); gtk_widget_show (frame); gtk_widget_set_sensitive (frame, gimp_drawable_has_alpha (drawable->drawable_id)); table = gtk_table_new (2, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (frame), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("F_irst color:"), 0, 0, svals.col1.a, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (alpha_scale_cb), push_col1); if (push_col1) g_signal_connect (push_col1, "color-changed", G_CALLBACK (alpha_scale_update), adj); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, _("S_econd color:"), 0, 0, svals.col2.a, 0.0, 1.0, 0.01, 0.1, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (alpha_scale_cb), push_col2); if (push_col2) g_signal_connect (push_col2, "color-changed", G_CALLBACK (alpha_scale_update), adj); gtk_widget_show (table); label = gtk_label_new_with_mnemonic (_("Co_lors")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); /* blend settings dialog: */ /* ====================== */ page = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (page), 12); frame = gimp_frame_new (_("Blend Settings")); gtk_box_pack_start (GTK_BOX (page), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 12); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); frame = gimp_int_radio_group_new (TRUE, _("Gradient"), G_CALLBACK (sinus_radio_button_update), &svals.colorization, svals.colorization, _("L_inear"), LINEAR, NULL, _("Bili_near"), BILINEAR, NULL, _("Sin_usoidal"), SINUS, NULL, NULL); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); table = gtk_table_new (1, 3, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_container_add (GTK_CONTAINER (vbox), table); adj = gimp_scale_entry_new (GTK_TABLE (table), 0, 0, _("_Exponent:"), 0, 0, svals.blend_power, -7.5, 7.5, 0.01, 5.0, 2, TRUE, 0, 0, NULL, NULL); g_signal_connect (adj, "value-changed", G_CALLBACK (sinus_double_adjustment_update), &svals.blend_power); gtk_widget_show (table); label = gtk_label_new_with_mnemonic (_("_Blend")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label); gtk_widget_show (page); gtk_widget_show (dlg); sinus_do_preview (preview); run = (gimp_dialog_run (GIMP_DIALOG (dlg)) == GTK_RESPONSE_OK); gtk_widget_destroy (dlg); return run; }
int Tetris::gameProperties(GtkAction *action, void *d) { GtkWidget *notebook; GtkWidget *vbox; GtkWidget *label; GtkWidget *frame; GtkWidget *table; GtkWidget *fvbox; GtkObject *adj; GtkWidget *controls_list; Tetris *t = (Tetris*) d; if (t->setupdialog) { gtk_window_present (GTK_WINDOW(t->setupdialog)); return FALSE; } /* create the dialog */ t->setupdialog = gtk_dialog_new_with_buttons(_("Gnometris Preferences"), GTK_WINDOW (t->w), (GtkDialogFlags)0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); gtk_dialog_set_has_separator (GTK_DIALOG (t->setupdialog), FALSE); gtk_container_set_border_width (GTK_CONTAINER (t->setupdialog), 5); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (t->setupdialog)->vbox), 2); g_signal_connect (t->setupdialog, "close", G_CALLBACK (setupdialogDestroy), d); g_signal_connect (t->setupdialog, "response", G_CALLBACK (setupdialogResponse), d); notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (notebook), 5); gtk_box_pack_start (GTK_BOX(GTK_DIALOG(t->setupdialog)->vbox), notebook, TRUE, TRUE, 0); /* game page */ vbox = gtk_vbox_new (FALSE, 18); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); label = gtk_label_new (_("Game")); gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label); frame = games_frame_new (_("Setup")); table = gtk_table_new (3, 2, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 12); /* pre-filled rows */ label = gtk_label_new_with_mnemonic (_("_Number of pre-filled rows:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) GTK_FILL, (GtkAttachOptions) 0, 0, 0); adj = gtk_adjustment_new (t->line_fill_height, 0, LINES-1, 1, 5, 0); t->fill_height_spinner = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 10, 0); gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (t->fill_height_spinner), GTK_UPDATE_ALWAYS); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (t->fill_height_spinner), TRUE); g_signal_connect (t->fill_height_spinner, "value_changed", G_CALLBACK (lineFillHeightChanged), t); gtk_table_attach_defaults (GTK_TABLE (table), t->fill_height_spinner, 1, 2, 0, 1); gtk_label_set_mnemonic_widget (GTK_LABEL (label), t->fill_height_spinner); /* pre-filled rows density */ label = gtk_label_new_with_mnemonic (_("_Density of blocks in a pre-filled row:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, (GtkAttachOptions) GTK_FILL, (GtkAttachOptions) 0, 0, 0); adj = gtk_adjustment_new (t->line_fill_prob, 0, 10, 1, 5, 0); t->fill_prob_spinner = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 10, 0); gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (t->fill_prob_spinner), GTK_UPDATE_ALWAYS); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (t->fill_prob_spinner), TRUE); g_signal_connect (t->fill_prob_spinner, "value_changed", G_CALLBACK (lineFillProbChanged), t); gtk_table_attach_defaults (GTK_TABLE (table), t->fill_prob_spinner, 1, 2, 1, 2); gtk_label_set_mnemonic_widget (GTK_LABEL (label), t->fill_prob_spinner); /* starting level */ label = gtk_label_new_with_mnemonic (_("_Starting level:")); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, (GtkAttachOptions) GTK_FILL, (GtkAttachOptions) 0, 0, 0); adj = gtk_adjustment_new (t->startingLevel, 1, 20, 1, 5, 0); t->sentry = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 10.0, 0); gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (t->sentry), GTK_UPDATE_ALWAYS); gtk_spin_button_set_snap_to_ticks (GTK_SPIN_BUTTON (t->sentry), TRUE); g_signal_connect (t->sentry, "value_changed", G_CALLBACK (startingLevelChanged), t); gtk_table_attach_defaults (GTK_TABLE (table), t->sentry, 1, 2, 2, 3); gtk_label_set_mnemonic_widget (GTK_LABEL (label), t->sentry); gtk_container_add (GTK_CONTAINER (frame), table); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = games_frame_new (_("Operation")); fvbox = gtk_vbox_new (FALSE, 6); /* sound */ t->sound_toggle = gtk_check_button_new_with_mnemonic (_("_Enable sounds")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (t->sound_toggle), games_sound_is_enabled ()); g_signal_connect (t->sound_toggle, "clicked", G_CALLBACK (setSound), d); gtk_box_pack_start (GTK_BOX (fvbox), t->sound_toggle, 0, 0, 0); /* preview next block */ t->do_preview_toggle = gtk_check_button_new_with_mnemonic (_("_Preview next block")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (t->do_preview_toggle), do_preview); g_signal_connect (t->do_preview_toggle, "clicked", G_CALLBACK (setSelectionPreview), d); gtk_box_pack_start (GTK_BOX (fvbox), t->do_preview_toggle, 0, 0, 0); /* random blocks */ t->random_block_colors_toggle = gtk_check_button_new_with_mnemonic (_("_Use random block colors")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (t->random_block_colors_toggle), random_block_colors); g_signal_connect (t->random_block_colors_toggle, "clicked", G_CALLBACK (setSelectionBlocks), d); gtk_box_pack_start (GTK_BOX (fvbox), t->random_block_colors_toggle, 0, 0, 0); /* rotate counter clock wise */ t->rotate_counter_clock_wise_toggle = gtk_check_button_new_with_mnemonic (_("_Rotate blocks counterclockwise")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (t->rotate_counter_clock_wise_toggle), rotateCounterClockWise); g_signal_connect (t->rotate_counter_clock_wise_toggle, "clicked", G_CALLBACK (setRotateCounterClockWise), d); gtk_box_pack_start (GTK_BOX (fvbox), t->rotate_counter_clock_wise_toggle, 0, 0, 0); t->useTargetToggle = gtk_check_button_new_with_mnemonic (_("Show _where the block will land")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (t->useTargetToggle), t->useTarget); g_signal_connect (t->useTargetToggle, "clicked", G_CALLBACK (setTarget), d); gtk_box_pack_start (GTK_BOX (fvbox), t->useTargetToggle, 0, 0, 0); gtk_container_add (GTK_CONTAINER (frame), fvbox); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); frame = games_frame_new (_("Theme")); table = gtk_table_new (2, 2, FALSE); gtk_container_set_border_width (GTK_CONTAINER (table), 0); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 12); /* controls page */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); label = gtk_label_new (_("Controls")); gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label); frame = games_frame_new (_("Keyboard Controls")); gtk_container_add (GTK_CONTAINER (vbox), frame); fvbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), fvbox); controls_list = games_controls_list_new (KEY_CONTROLS_GROUP); games_controls_list_add_controls (GAMES_CONTROLS_LIST (controls_list), KEY_MOVE_LEFT, _("Move left"), GDK_Left, KEY_MOVE_RIGHT, _("Move right"), GDK_Right, KEY_MOVE_DOWN, _("Move down"), GDK_Down, KEY_MOVE_DROP, _("Drop"), GDK_Pause, KEY_MOVE_ROTATE, _("Rotate"), GDK_Up, KEY_MOVE_PAUSE, _("Pause"), GDK_space, NULL); gtk_box_pack_start (GTK_BOX (fvbox), controls_list, TRUE, TRUE, 0); /* theme page */ vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); label = gtk_label_new (_("Theme")); gtk_notebook_append_page (GTK_NOTEBOOK(notebook), vbox, label); frame = games_frame_new (_("Block Style")); gtk_container_add (GTK_CONTAINER (vbox), frame); fvbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), fvbox); GtkWidget *omenu = gtk_combo_box_new_text (); const ThemeTableEntry *entry = ThemeTable; while (entry->id) { gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), entry->name); entry++; } gtk_combo_box_set_active (GTK_COMBO_BOX (omenu), t->themeno); g_signal_connect (omenu, "changed", G_CALLBACK (setSelection), t); gtk_box_pack_start (GTK_BOX (fvbox), omenu, FALSE, FALSE, 0); t->theme_preview = new Preview(); t->theme_preview->setTheme (t->themeno); gtk_box_pack_start(GTK_BOX(fvbox), t->theme_preview->getWidget(), TRUE, TRUE, 0); t->theme_preview->previewBlock(4, 0, 0); gtk_widget_show_all (t->setupdialog); gtk_action_set_sensitive(t->new_game_action, FALSE); return TRUE; }
static void create_adapter(adapter_data *adapter) { GHashTable *hash = NULL; GValue *value; DBusGProxy *default_proxy; const gchar *name; gboolean powered, discoverable; guint timeout; GtkWidget *mainbox; GtkWidget *vbox; GtkWidget *alignment; GtkWidget *table; GtkWidget *label; GtkWidget *image; GtkWidget *button; GtkWidget *entry; GtkWidget *buttonbox; int page_num; dbus_g_proxy_call(adapter->proxy, "GetProperties", NULL, G_TYPE_INVALID, dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE), &hash, G_TYPE_INVALID); if (hash != NULL) { value = g_hash_table_lookup(hash, "Name"); name = value ? g_value_get_string(value) : NULL; value = g_hash_table_lookup(hash, "Powered"); powered = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "Discoverable"); discoverable = value ? g_value_get_boolean(value) : FALSE; value = g_hash_table_lookup(hash, "DiscoverableTimeout"); timeout = value ? g_value_get_uint(value) : 0; } else { name = NULL; powered = FALSE; discoverable = FALSE; timeout = 0; } adapter->powered = powered; adapter->discoverable = discoverable; adapter->timeout_value = timeout; default_proxy = bluetooth_client_get_default_adapter (client); if (default_proxy != NULL) { adapter->is_default = g_str_equal (dbus_g_proxy_get_path (default_proxy), dbus_g_proxy_get_path (adapter->proxy)); g_object_unref (default_proxy); } mainbox = gtk_vbox_new(FALSE, 6); gtk_container_set_border_width(GTK_CONTAINER(mainbox), 12); page_num = gtk_notebook_prepend_page(GTK_NOTEBOOK(adapter->notebook), mainbox, NULL); adapter->child = mainbox; vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, TRUE, 0); /* The discoverable checkbox */ button = gtk_check_button_new_with_mnemonic (_("Make computer _visible")); if (powered == FALSE) discoverable = FALSE; if (discoverable != FALSE && timeout == 0) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); else if (discoverable == FALSE) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), FALSE); else { gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE); gtk_toggle_button_set_inconsistent (GTK_TOGGLE_BUTTON (button), TRUE); } gtk_widget_set_sensitive (button, adapter->powered); adapter->button_discoverable = button; adapter->signal_discoverable = g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(discoverable_changed_cb), adapter); gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0); /* The friendly name */ vbox = gtk_vbox_new(FALSE, 6); gtk_box_pack_start(GTK_BOX(mainbox), vbox, FALSE, FALSE, 0); label = create_label(_("Friendly name")); gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_box_pack_start (GTK_BOX (vbox), alignment, TRUE, TRUE, 0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry), 248); gtk_widget_set_size_request(entry, 240, -1); gtk_container_add (GTK_CONTAINER (alignment), entry); if (name != NULL) gtk_entry_set_text(GTK_ENTRY(entry), name); adapter->entry = entry; adapter->name_vbox = vbox; g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(name_callback), adapter); g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(focus_callback), adapter); gtk_widget_set_sensitive (adapter->name_vbox, adapter->powered); /* The known devices */ table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(mainbox), table, TRUE, TRUE, 0); label = create_label(_("Devices")); gtk_table_attach(GTK_TABLE(table), label, 0, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_SHRINK, 0, 6); /* Note that this will only ever show the devices on the default * adapter, this is on purpose */ adapter->chooser = bluetooth_chooser_new (NULL); g_object_set (adapter->chooser, "show-searching", FALSE, "show-device-type", FALSE, "show-device-category", FALSE, "show-pairing", TRUE, "show-connected", TRUE, "device-category-filter", BLUETOOTH_CATEGORY_PAIRED_OR_TRUSTED, NULL); g_signal_connect (adapter->chooser, "notify::device-selected", G_CALLBACK(device_selected_cb), adapter); gtk_table_attach(GTK_TABLE(table), adapter->chooser, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); adapter->devices_table = table; buttonbox = gtk_vbutton_box_new(); gtk_button_box_set_layout(GTK_BUTTON_BOX(buttonbox), GTK_BUTTONBOX_START); gtk_box_set_spacing(GTK_BOX(buttonbox), 6); gtk_box_set_homogeneous(GTK_BOX(buttonbox), FALSE); gtk_table_attach(GTK_TABLE(table), buttonbox, 1, 2, 1, 2, GTK_FILL, GTK_FILL, 6, 6); button = gtk_button_new_with_mnemonic(_("Set up _new device...")); image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(wizard_callback), adapter); button = gtk_button_new_with_label(_("Disconnect")); image = gtk_image_new_from_stock(GTK_STOCK_DISCONNECT, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(disconnect_callback), adapter); adapter->button_disconnect = button; button = gtk_button_new_with_mnemonic(_("_Remove")); image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_BUTTON); gtk_button_set_image(GTK_BUTTON(button), image); gtk_box_pack_end(GTK_BOX(buttonbox), button, FALSE, FALSE, 0); gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(buttonbox), button, TRUE); gtk_widget_set_sensitive(button, FALSE); g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(remove_callback), adapter); adapter->button_delete = button; gtk_widget_set_sensitive (adapter->devices_table, adapter->powered); g_object_set_data(G_OBJECT(mainbox), "adapter", adapter); gtk_widget_show_all(mainbox); if (adapter->is_default != FALSE) gtk_notebook_set_current_page (GTK_NOTEBOOK (adapter->notebook), page_num); }
static void tip_blind_dialog(TipBlindArgs *args) { GtkWidget *dialog, *table, *hbox, *vbox, *label; GwyContainer *data; GwyGraphModel *gmodel; GwyGraphArea *area; TipBlindControls controls; GwyPixmapLayer *layer; GwyDataField *dfield; GQuark quark; GwySIUnit *unit; gint response, row; dialog = gtk_dialog_new_with_buttons(_("Blind Tip Estimation"), NULL, 0, _("Run _Partial"), RESPONSE_ESTIMATE, _("Run _Full"), RESPONSE_REFINE, _("_Reset Tip"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT); controls.args = args; controls.in_update = TRUE; controls.good_tip = FALSE; controls.dialog = dialog; gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK, controls.good_tip); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, FALSE, 4); controls.vxres = 240; controls.vyres = 240; controls.oldnstripes = args->nstripes; /* set initial tip properties */ data = gwy_app_data_browser_get(args->source.datano); quark = gwy_app_get_data_key_for_id(args->source.id); dfield = GWY_DATA_FIELD(gwy_container_get_object(data, quark)); controls.tip = gwy_data_field_new_alike(dfield, TRUE); gwy_data_field_resample(controls.tip, args->xres, args->yres, GWY_INTERPOLATION_NONE); gwy_data_field_clear(controls.tip); /* set up data of rescaled image of the tip */ controls.vtip = gwy_container_new(); gwy_app_sync_data_items(data, controls.vtip, args->source.id, 0, FALSE, GWY_DATA_ITEM_PALETTE, 0); dfield = gwy_data_field_new_alike(controls.tip, TRUE); gwy_data_field_resample(dfield, controls.vxres, controls.vyres, GWY_INTERPOLATION_ROUND); gwy_container_set_object_by_name(controls.vtip, "/0/data", dfield); g_object_unref(dfield); /* set up rescaled image of the tip */ vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4); controls.view = gwy_data_view_new(controls.vtip); layer = gwy_layer_basic_new(); gwy_pixmap_layer_set_data_key(layer, "/0/data"); gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette"); gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer); /* set up tip estimation controls */ gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0); gmodel = gwy_graph_model_new(); controls.graph = gwy_graph_new(gmodel); g_object_unref(gmodel); gwy_axis_set_visible(gwy_graph_get_axis(GWY_GRAPH(controls.graph), GTK_POS_LEFT), FALSE); gwy_axis_set_visible(gwy_graph_get_axis(GWY_GRAPH(controls.graph), GTK_POS_BOTTOM), FALSE); area = GWY_GRAPH_AREA(gwy_graph_get_area(GWY_GRAPH(controls.graph))); gtk_widget_set_no_show_all(gwy_graph_area_get_label(area), TRUE); g_signal_connect_after(gwy_graph_area_get_label(area), "map", G_CALLBACK(gtk_widget_hide), NULL); gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 0); table = gtk_table_new(13, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(hbox), table, FALSE, FALSE, 4); row = 0; controls.data = gwy_data_chooser_new_channels(); gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(controls.data), tip_blind_source_filter, &args->orig, NULL); gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(controls.data), &args->source); g_signal_connect(controls.data, "changed", G_CALLBACK(data_changed), &args->source); gwy_table_attach_hscale(table, row, _("Related _data:"), NULL, GTK_OBJECT(controls.data), GWY_HSCALE_WIDGET); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; label = gtk_label_new(_("Estimated Tip Size")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 4, row, row+1, GTK_FILL, 0, 0, 0); row++; controls.xres = gtk_adjustment_new(args->xres, MIN_RES, MAX_RES, 1, 10, 0); gwy_table_attach_hscale(table, row, _("_Width:"), "px", controls.xres, 0); g_object_set_data(G_OBJECT(controls.xres), "controls", &controls); g_signal_connect(controls.xres, "value-changed", G_CALLBACK(width_changed), &controls); row++; controls.yres = gtk_adjustment_new(args->yres, MIN_RES, MAX_RES, 1, 10, 0); gwy_table_attach_hscale(table, row, _("_Height:"), "px", controls.yres, 0); g_object_set_data(G_OBJECT(controls.yres), "controls", &controls); g_signal_connect(controls.yres, "value-changed", G_CALLBACK(height_changed), &controls); row++; controls.same_resolution = gtk_check_button_new_with_mnemonic(_("_Same resolution")); gtk_table_attach(GTK_TABLE(table), controls.same_resolution, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.same_resolution), args->same_resolution); g_signal_connect(controls.same_resolution, "toggled", G_CALLBACK(same_resolution_changed), &controls); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Options")), 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.threshold = gtk_adjustment_new(1.0, 0.01, 1000.0, 0.01, 1.0, 0.0); controls.threshold_spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.threshold), 0.1, 2); gtk_table_attach(GTK_TABLE(table), controls.threshold_spin, 2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); label = gtk_label_new_with_mnemonic(_("Noise suppression t_hreshold:")); gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.threshold_spin); gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); unit = gwy_data_field_get_si_unit_z(dfield); controls.threshold_unit = gwy_combo_box_metric_unit_new(G_CALLBACK(thresh_changed), &controls, -12, -3, unit, -9); gtk_table_attach(GTK_TABLE(table), controls.threshold_unit, 3, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_signal_connect(controls.threshold, "value-changed", G_CALLBACK(thresh_changed), &controls); sci_entry_set_value(GTK_ADJUSTMENT(controls.threshold), GTK_COMBO_BOX(controls.threshold_unit), args->thresh); row++; controls.boundaries = gtk_check_button_new_with_mnemonic(_("Use _boundaries")); gtk_table_attach(GTK_TABLE(table), controls.boundaries, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.boundaries), args->use_boundaries); g_signal_connect(controls.boundaries, "toggled", G_CALLBACK(bound_changed), args); gtk_table_set_row_spacing(GTK_TABLE(table), row, 8); row++; gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Stripes")), 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); row++; controls.nstripes = gtk_adjustment_new(args->nstripes, MIN_STRIPES, MAX_STRIPES, 1, 10, 0); gwy_table_attach_hscale(table, row, _("_Split to stripes:"), NULL, controls.nstripes, GWY_HSCALE_CHECK); controls.split_to_stripes = gwy_table_hscale_get_check(controls.nstripes); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.split_to_stripes), !args->split_to_stripes); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.split_to_stripes), args->split_to_stripes); g_signal_connect(controls.split_to_stripes, "toggled", G_CALLBACK(split_to_stripes_changed), &controls); g_signal_connect(controls.nstripes, "value-changed", G_CALLBACK(nstripes_changed), &controls); row++; controls.stripeno = gtk_adjustment_new(1, 1, args->nstripes, 1, 10, 0); gwy_table_attach_hscale(table, row, _("_Preview stripe:"), NULL, controls.stripeno, GWY_HSCALE_DEFAULT); g_signal_connect(controls.stripeno, "value-changed", G_CALLBACK(stripeno_changed), &controls); row++; controls.plot_size_graph = gtk_check_button_new_with_mnemonic(_("Plot size _graph")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.plot_size_graph), args->plot_size_graph); gtk_table_attach(GTK_TABLE(table), controls.plot_size_graph, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_signal_connect(controls.plot_size_graph, "toggled", G_CALLBACK(plot_size_graph_changed), &controls); row++; controls.create_images = gtk_check_button_new_with_mnemonic(_("Create tip i_mages")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.create_images), args->create_images); gtk_table_attach(GTK_TABLE(table), controls.create_images, 0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0); g_signal_connect(controls.create_images, "toggled", G_CALLBACK(create_images_changed), &controls); row++; controls.tipdone = FALSE; controls.in_update = FALSE; split_to_stripes_changed(GTK_TOGGLE_BUTTON(controls.split_to_stripes), &controls); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: tip_blind_dialog_abandon(&controls); tip_blind_save_args(gwy_app_settings_get(), args); return; break; case GTK_RESPONSE_OK: tip_blind_save_args(gwy_app_settings_get(), args); tip_blind_do(&controls, args); break; case RESPONSE_RESET: reset(&controls, args); break; case RESPONSE_ESTIMATE: tip_blind_run(&controls, args, FALSE); break; case RESPONSE_REFINE: tip_blind_run(&controls, args, TRUE); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(dialog); tip_blind_dialog_abandon(&controls); return; }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *vbox3; GtkWidget *label1; GtkWidget *hscaleContrast; GtkWidget *label2; GtkWidget *hscaleBright; GtkWidget *vbox2; GtkWidget *checkLuma; GtkWidget *checkbuttonU; GtkWidget *checkbuttonV; GtkWidget *hscale1; GtkWidget *drawingarea1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Contrast")); gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0); vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox3); gtk_box_pack_start (GTK_BOX (hbox1), vbox3, TRUE, TRUE, 0); label1 = gtk_label_new (QT_TR_NOOP("Contrast")); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (vbox3), label1, FALSE, FALSE, 0); hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.5, 1.5, 0.1, 0.1, 0))); gtk_widget_show (hscaleContrast); gtk_box_pack_start (GTK_BOX (vbox3), hscaleContrast, FALSE, TRUE, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_LEFT); label2 = gtk_label_new (QT_TR_NOOP("Brightness")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (vbox3), label2, FALSE, FALSE, 0); hscaleBright = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -127, 127, 1, 1, 0))); gtk_widget_show (hscaleBright); gtk_box_pack_start (GTK_BOX (vbox3), hscaleBright, FALSE, TRUE, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleBright), GTK_POS_LEFT); gtk_scale_set_digits (GTK_SCALE (hscaleBright), 0); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0); checkLuma = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Luma")); gtk_widget_show (checkLuma); gtk_box_pack_start (GTK_BOX (vbox2), checkLuma, FALSE, FALSE, 0); checkbuttonU = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Chroma U")); gtk_widget_show (checkbuttonU); gtk_box_pack_start (GTK_BOX (vbox2), checkbuttonU, FALSE, FALSE, 0); checkbuttonV = gtk_check_button_new_with_mnemonic (QT_TR_NOOP("Chroma v")); gtk_widget_show (checkbuttonV); gtk_box_pack_start (GTK_BOX (vbox2), checkbuttonV, FALSE, FALSE, 0); hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 99, 1, 1, 0))); gtk_widget_show (hscale1); gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0); drawingarea1 = gtk_drawing_area_new (); gtk_widget_show (drawingarea1); gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 0); gtk_widget_set_size_request (drawingarea1, -1, 300); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox3, "vbox3"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, hscaleBright, "hscaleBright"); GLADE_HOOKUP_OBJECT (dialog1, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (dialog1, checkLuma, "checkLuma"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonU, "checkbuttonU"); GLADE_HOOKUP_OBJECT (dialog1, checkbuttonV, "checkbuttonV"); GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1"); GLADE_HOOKUP_OBJECT (dialog1, drawingarea1, "drawingarea1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
static gboolean scale_dialog(ScaleArgs *args) { GtkWidget *dialog, *table, *spin; ScaleControls controls; enum { RESPONSE_RESET = 1 }; gint response; dialog = gtk_dialog_new_with_buttons(_("Scale"), NULL, 0, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); table = gtk_table_new(4, 5, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, FALSE, FALSE, 4); controls.ratio = gtk_adjustment_new(args->ratio, 2.0/MIN(args->xres, args->yres), 4096.0/MAX(args->xres, args->yres), 0.01, 0.2, 0); spin = gwy_table_attach_hscale(table, 0, _("Scale by _ratio:"), NULL, controls.ratio, GWY_HSCALE_LOG); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 3); g_object_set_data(G_OBJECT(controls.ratio), "controls", &controls); g_signal_connect(controls.ratio, "value-changed", G_CALLBACK(scale_changed_cb), args); controls.proportional = gtk_check_button_new_with_mnemonic(_("_proportional")); gtk_table_attach_defaults(GTK_TABLE(table), controls.proportional, 3, 4, 0, 1); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.proportional), args->proportional); g_object_set_data(G_OBJECT(controls.proportional), "controls", &controls); g_signal_connect(controls.proportional, "toggled", G_CALLBACK(proportional_changed_cb), args); controls.xres = gtk_adjustment_new(args->ratio*args->xres, 2, 4096, 1, 10, 0); spin = gwy_table_attach_hscale(table, 1, _("New _width:"), "px", controls.xres, GWY_HSCALE_LOG); g_object_set_data(G_OBJECT(controls.xres), "controls", &controls); g_signal_connect(controls.xres, "value-changed", G_CALLBACK(width_changed_cb), args); controls.yres = gtk_adjustment_new(args->ratio*args->yres, 2, 4096, 1, 10, 0); spin = gwy_table_attach_hscale(table, 2, _("New _height:"), "px", controls.yres, GWY_HSCALE_LOG); g_object_set_data(G_OBJECT(controls.yres), "controls", &controls); g_signal_connect(controls.yres, "value-changed", G_CALLBACK(height_changed_cb), args); controls.interp = gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1, G_CALLBACK(gwy_enum_combo_box_update_int), &args->interp, args->interp, TRUE); gwy_table_attach_hscale(table, 3, _("_Interpolation type:"), NULL, GTK_OBJECT(controls.interp), GWY_HSCALE_WIDGET); controls.in_update = FALSE; scale_dialog_update(&controls, args); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: args->ratio = gtk_adjustment_get_value(GTK_ADJUSTMENT(controls.ratio)); gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: args->ratio = scale_defaults.ratio; args->xres = args->org_xres; args->yres = args->org_yres; args->proportional = scale_defaults.proportional; args->aspectratio = scale_defaults.aspectratio; args->interp = scale_defaults.interp; scale_dialog_update(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); args->ratio = gtk_adjustment_get_value(GTK_ADJUSTMENT(controls.ratio)); gtk_widget_destroy(dialog); return TRUE; }
static void lcrt_serial_show(struct lcrt_qconnect *lqconnect) { GtkWidget *vbox; GtkWidget *vbox_spec; GtkWidget *hbox1; GtkWidget *label_port; GtkWidget *combobox_port; GtkWidget *label_baud_rate; GtkWidget *combobox_baud_rate; GtkWidget *label_data_bits; GtkWidget *combobox_data_bits; GtkWidget *label_parity; GtkWidget *combobox_parity; GtkWidget *label_stop_bits; GtkWidget *combobox_stop_bits; GtkWidget *frame; GtkWidget *alignment; GtkWidget *hbox_frame; GtkWidget *checkbutton_software; GtkWidget *checkbutton_hardware; GtkWidget *label_flow_control; int i; const char *sport[LCRT_SERIAL_PORT_NUMBER] = {LCRT_SERIAL_PORT}; const struct lcrt_serial_map sbaud_rate[LCRT_SERIAL_BAUD_RATE_NUMBER] = {LCRT_SERIAL_BAUD_RATE_TABLE}; const struct lcrt_serial_map sdata_bits[LCRT_SERIAL_DATA_BITS_NUMBER] = {LCRT_SERIAL_DATA_BITS_TABLE}; const struct lcrt_serial_map sparity[LCRT_SERIAL_PARITY_NUMBER] = {LCRT_SERIAL_PARITY_TABLE}; const struct lcrt_serial_map sstop_bits[LCRT_SERIAL_STOP_BITS_NUMBER] = {LCRT_SERIAL_STOP_BITS_TABLE}; const struct lcrt_serial_map flow_control[LCRT_SEROAL_FLOW_CONTROL_NUMBER] = {LCRT_SEROAL_FLOW_CONTROL_TABLE}; static struct lcrt_serial_if slserial, *lserial = &slserial; struct lcrtc_user *user = NULL; char s_port[USERNAME_LEN]; boolean f_option = FALSE; int s_baud_rate,s_databit,s_parity,s_stopbit,s_software,s_hardware; if (lqconnect->flag == LCRT_QCONNECT_SESSION_OPTION && (user = lcrt_user_find_by_name(&lqconnect->parent->u_config, lqconnect->uname)) != NULL) { sscanf(user->password, "%s %d %d %d %d %d %d", s_port, &s_baud_rate, &s_databit, &s_parity, &s_stopbit, &s_software, &s_hardware); debug_print("SERIAL PORT: %s %d %d %d %d %d %d\n", s_port, s_baud_rate, s_databit, s_parity, s_stopbit, s_software, s_hardware); f_option = TRUE; } memset(lserial, 0, sizeof(struct lcrt_serial_if)); lqconnect->private_data = lserial; vbox = GTK_DIALOG (lqconnect->q_connect)->vbox; debug_where(); vbox_spec = gtk_vbox_new (FALSE, 0); lqconnect->q_vbox_spec = vbox_spec; gtk_widget_show (vbox_spec); gtk_box_pack_start (GTK_BOX (vbox), vbox_spec, TRUE, TRUE, 0); gtk_box_reorder_child (GTK_BOX (vbox), vbox_spec, 1); gtk_widget_set_size_request (vbox_spec, -1, 210); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_port = gtk_label_new (lqconnect->config.value[LCRT_Q_SPORT]); gtk_widget_show (label_port); gtk_box_pack_start (GTK_BOX (hbox1), label_port, FALSE, FALSE, 0); gtk_widget_set_size_request (label_port, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_port), 0, 0.5); combobox_port = gtk_combo_box_entry_new_text (); lserial->port = combobox_port; gtk_widget_show (combobox_port); gtk_box_pack_start (GTK_BOX (hbox1), combobox_port, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_port, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_PORT_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_port), sport[i]); if (f_option && strcmp(s_port, sport[i]) == 0) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_port), i); } debug_where(); //gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_port)->child), FALSE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_baud_rate = gtk_label_new (lqconnect->config.value[LCRT_Q_SBAUD_RATE]); gtk_widget_show (label_baud_rate); gtk_box_pack_start (GTK_BOX (hbox1), label_baud_rate, FALSE, FALSE, 0); gtk_widget_set_size_request (label_baud_rate, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_baud_rate), 0, 0.5); combobox_baud_rate = gtk_combo_box_entry_new_text (); lserial->baud_rate = combobox_baud_rate; gtk_widget_show (combobox_baud_rate); gtk_box_pack_start (GTK_BOX (hbox1), combobox_baud_rate, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_baud_rate, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_BAUD_RATE_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_baud_rate), sbaud_rate[i].name); if (f_option && s_baud_rate == sbaud_rate[i].data) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_baud_rate), i); } debug_where(); gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_baud_rate)->child), FALSE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_data_bits = gtk_label_new (lqconnect->config.value[LCRT_Q_SDATA_BITS]); gtk_widget_show (label_data_bits); gtk_box_pack_start (GTK_BOX (hbox1), label_data_bits, FALSE, FALSE, 0); gtk_widget_set_size_request (label_data_bits, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_data_bits), 0, 0.5); combobox_data_bits = gtk_combo_box_entry_new_text (); lserial->data_bits = combobox_data_bits; gtk_widget_show (combobox_data_bits); gtk_box_pack_start (GTK_BOX (hbox1), combobox_data_bits, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_data_bits, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_DATA_BITS_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_data_bits), sdata_bits[i].name); if (f_option && s_databit == sdata_bits[i].data) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_data_bits), i); } debug_where(); gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_data_bits)->child), FALSE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_parity = gtk_label_new (lqconnect->config.value[LCRT_Q_SPARITY]); gtk_widget_show (label_parity); gtk_box_pack_start (GTK_BOX (hbox1), label_parity, FALSE, FALSE, 0); gtk_widget_set_size_request (label_parity, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_parity), 0, 0.5); combobox_parity = gtk_combo_box_entry_new_text (); lserial->parity = combobox_parity; gtk_widget_show (combobox_parity); gtk_box_pack_start (GTK_BOX (hbox1), combobox_parity, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_parity, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_PARITY_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_parity), sparity[i].name); } if (f_option) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_parity), s_parity); debug_where(); gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_parity)->child), FALSE); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox_spec), hbox1, TRUE, TRUE, 0); gtk_widget_set_size_request (hbox1, -1, 25); label_stop_bits = gtk_label_new (lqconnect->config.value[LCRT_Q_SSTOP_BITS]); gtk_widget_show (label_stop_bits); gtk_box_pack_start (GTK_BOX (hbox1), label_stop_bits, FALSE, FALSE, 0); gtk_widget_set_size_request (label_stop_bits, 90, 25); gtk_misc_set_alignment (GTK_MISC (label_stop_bits), 0, 0.5); combobox_stop_bits = gtk_combo_box_entry_new_text (); lserial->stop_bits = combobox_stop_bits; gtk_widget_show (combobox_stop_bits); gtk_box_pack_start (GTK_BOX (hbox1), combobox_stop_bits, FALSE, TRUE, 0); gtk_widget_set_size_request (combobox_stop_bits, SERIAL_COMBOBOX_WIDTH, 25); for (i = 0; i < LCRT_SERIAL_STOP_BITS_NUMBER; i++) { gtk_combo_box_append_text (GTK_COMBO_BOX (combobox_stop_bits), sstop_bits[i].name); } if (f_option) gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_stop_bits), s_stopbit); debug_where(); gtk_entry_set_editable(GTK_ENTRY(GTK_BIN(combobox_stop_bits)->child), FALSE); frame = gtk_frame_new (NULL); gtk_widget_show (frame); gtk_widget_set_size_request (frame, -1, 40); gtk_box_pack_start (GTK_BOX (vbox_spec), frame, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); alignment = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment); gtk_container_add (GTK_CONTAINER (frame), alignment); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 12, 0); hbox_frame = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox_frame); gtk_container_add (GTK_CONTAINER (alignment), hbox_frame); checkbutton_software = gtk_check_button_new_with_mnemonic (flow_control[0].name); lserial->software = checkbutton_software; gtk_widget_show (checkbutton_software); gtk_box_pack_start (GTK_BOX (hbox_frame), checkbutton_software, FALSE, FALSE, 0); gtk_widget_set_size_request (checkbutton_software, 150, -1); if (f_option) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_software), s_software); checkbutton_hardware = gtk_check_button_new_with_mnemonic (flow_control[1].name); lserial->hardware = checkbutton_hardware; gtk_widget_show (checkbutton_hardware); gtk_box_pack_start (GTK_BOX (hbox_frame), checkbutton_hardware, FALSE, FALSE, 0); gtk_widget_set_size_request (checkbutton_hardware, 150, -1); if (f_option) gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_hardware), s_hardware); label_flow_control = gtk_label_new (lqconnect->config.value[LCRT_Q_SFLOW_CONTROL]); gtk_widget_show (label_flow_control); gtk_frame_set_label_widget (GTK_FRAME (frame), label_flow_control); gtk_label_set_use_markup (GTK_LABEL (label_flow_control), TRUE); if (!f_option) { gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_port), 1); //ttyS0 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_baud_rate), 10); //115200 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_data_bits), 3); //8 gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_parity), 0); //None gtk_combo_box_set_active(GTK_COMBO_BOX(combobox_stop_bits), 0); //1 debug_print("active = %d\n", gtk_combo_box_get_active(GTK_COMBO_BOX(combobox_baud_rate))); } gtk_widget_set_sensitive(lqconnect->q_bt_connect, TRUE); }
static gboolean shoot_dialog (GdkScreen **screen) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *notebook; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *button; GtkWidget *toggle; GtkWidget *spinner; GdkPixbuf *pixbuf; GSList *radio_group = NULL; GtkObject *adj; gboolean run; gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Screenshot"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, PLUG_IN_PROC, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog), _("S_nap"), GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); pixbuf = gdk_pixbuf_new_from_inline (-1, screenshot_icon, FALSE, NULL); if (pixbuf) { gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_pixbuf (pixbuf)); g_object_unref (pixbuf); } main_vbox = gtk_vbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show (main_vbox); /* Hints */ notebook = g_object_new (GTK_TYPE_NOTEBOOK, "show-border", FALSE, "show-tabs", FALSE, NULL); gtk_box_pack_end (GTK_BOX (main_vbox), notebook, FALSE, FALSE, 0); gtk_widget_show (notebook); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_ROOT, _("After the delay, the screenshot is taken.")); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_REGION, _("After the delay, drag your mouse to select " "the region for the screenshot.")); shoot_dialog_add_hint (GTK_NOTEBOOK (notebook), SHOOT_WINDOW, _("At the end of the delay, click in a window " "to snap it.")); gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), shootvals.shoot_type); /* Area */ frame = gimp_frame_new (_("Area")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); /* single window */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Take a screenshot of " "a single _window")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_WINDOW); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_WINDOW)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); #ifdef HAVE_X11_XMU_WINUTIL_H hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); toggle = gtk_check_button_new_with_mnemonic (_("Include window _decoration")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), shootvals.decorate); gtk_box_pack_start (GTK_BOX (hbox), toggle, TRUE, TRUE, 24); gtk_widget_show (toggle); g_object_set_data (G_OBJECT (button), "set_sensitive", toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &shootvals.decorate); #endif /* HAVE_X11_XMU_WINUTIL_H */ /* whole screen */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Take a screenshot of " "the entire _screen")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_ROOT); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_ROOT)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); /* dragged region */ button = gtk_radio_button_new_with_mnemonic (radio_group, _("Select a _region to grab")); radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (button)); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), shootvals.shoot_type == SHOOT_REGION); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_object_set_data (G_OBJECT (button), "gimp-item-data", GINT_TO_POINTER (SHOOT_REGION)); g_signal_connect (button, "toggled", G_CALLBACK (shoot_radio_button_toggled), notebook); /* Delay */ frame = gimp_frame_new (_("Delay")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_vbox_new (FALSE, 6); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); spinner = gimp_spin_button_new (&adj, shootvals.select_delay, 0.0, 100.0, 1.0, 5.0, 0.0, 0, 0); gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, FALSE, 0); gtk_widget_show (spinner); g_signal_connect (adj, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &shootvals.select_delay); /* this is the unit label of a spinbutton */ label = gtk_label_new (_("seconds")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { /* get the screen on which we are running */ *screen = gtk_widget_get_screen (dialog); } gtk_widget_destroy (dialog); if (run) { /* A short timeout to give the server a chance to * redraw the area that was obscured by our dialog. */ g_timeout_add (100, shoot_quit_timeout, NULL); gtk_main (); } return run; }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *table1; GtkWidget *label1; GtkWidget *label2; GtkWidget *entry_width; GtkWidget *entry_height; GtkWidget *label3; GtkWidget *label_errorx; GtkWidget *label7; GtkWidget *label_errory; GtkWidget *vbox2; GtkWidget *label5; GtkWidget *label6; GtkWidget *hseparator1; GtkWidget *vbox3; GtkWidget *optionmenu_source; GtkWidget *menu1; GtkWidget *item1_1; GtkWidget *_4_1; GtkWidget *_16_1; GtkWidget *optionmenu_dest; GtkWidget *menu2; GtkWidget *menuitem1; GtkWidget *menuitem2; GtkWidget *menuitem3; GtkWidget *checkbutton_16; GtkWidget *optionmenu1; GtkWidget *menu3; GtkWidget *bilinear1; GtkWidget *bicubic1; GtkWidget *lanczos1; GtkWidget *hscale1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *applybutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), _("Resize")); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0); table1 = gtk_table_new (4, 2, FALSE); gtk_widget_show (table1); gtk_box_pack_start (GTK_BOX (hbox1), table1, TRUE, TRUE, 0); label1 = gtk_label_new (_(" Width ")); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5); label2 = gtk_label_new (_(" Height ")); gtk_widget_show (label2); gtk_table_attach (GTK_TABLE (table1), label2, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5); entry_width = gtk_entry_new (); gtk_widget_show (entry_width); gtk_table_attach (GTK_TABLE (table1), entry_width, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); entry_height = gtk_entry_new (); gtk_widget_show (entry_height); gtk_table_attach (GTK_TABLE (table1), entry_height, 1, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); label3 = gtk_label_new (_(" Error X:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5); label_errorx = gtk_label_new (_("0")); gtk_widget_show (label_errorx); gtk_table_attach (GTK_TABLE (table1), label_errorx, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_errorx), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_errorx), 0, 0.5); label7 = gtk_label_new (_(" Error Y:")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5); label_errory = gtk_label_new (_("0")); gtk_widget_show (label_errory); gtk_table_attach (GTK_TABLE (table1), label_errory, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label_errory), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label_errory), 0, 0.5); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0); label5 = gtk_label_new (_("Source :")); gtk_widget_show (label5); gtk_box_pack_start (GTK_BOX (vbox2), label5, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); label6 = gtk_label_new (_("Destination")); gtk_widget_show (label6); gtk_box_pack_start (GTK_BOX (vbox2), label6, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); hseparator1 = gtk_hseparator_new (); gtk_widget_show (hseparator1); gtk_box_pack_start (GTK_BOX (vbox2), hseparator1, FALSE, FALSE, 0); vbox3 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox3); gtk_box_pack_start (GTK_BOX (hbox1), vbox3, TRUE, TRUE, 0); optionmenu_source = gtk_option_menu_new (); gtk_widget_show (optionmenu_source); gtk_box_pack_start (GTK_BOX (vbox3), optionmenu_source, FALSE, FALSE, 0); menu1 = gtk_menu_new (); item1_1 = gtk_menu_item_new_with_mnemonic (_("1:1")); gtk_widget_show (item1_1); gtk_container_add (GTK_CONTAINER (menu1), item1_1); _4_1 = gtk_menu_item_new_with_mnemonic (_("4:3")); gtk_widget_show (_4_1); gtk_container_add (GTK_CONTAINER (menu1), _4_1); _16_1 = gtk_menu_item_new_with_mnemonic (_("16:9")); gtk_widget_show (_16_1); gtk_container_add (GTK_CONTAINER (menu1), _16_1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_source), menu1); optionmenu_dest = gtk_option_menu_new (); gtk_widget_show (optionmenu_dest); gtk_box_pack_start (GTK_BOX (vbox3), optionmenu_dest, FALSE, FALSE, 0); menu2 = gtk_menu_new (); menuitem1 = gtk_menu_item_new_with_mnemonic (_("1:1")); gtk_widget_show (menuitem1); gtk_container_add (GTK_CONTAINER (menu2), menuitem1); menuitem2 = gtk_menu_item_new_with_mnemonic (_("4:3")); gtk_widget_show (menuitem2); gtk_container_add (GTK_CONTAINER (menu2), menuitem2); menuitem3 = gtk_menu_item_new_with_mnemonic (_("16:9")); gtk_widget_show (menuitem3); gtk_container_add (GTK_CONTAINER (menu2), menuitem3); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu_dest), menu2); checkbutton_16 = gtk_check_button_new_with_mnemonic (_("16 round up")); gtk_widget_show (checkbutton_16); gtk_box_pack_start (GTK_BOX (vbox3), checkbutton_16, FALSE, FALSE, 0); optionmenu1 = gtk_option_menu_new (); gtk_widget_show (optionmenu1); gtk_box_pack_start (GTK_BOX (vbox3), optionmenu1, FALSE, FALSE, 0); menu3 = gtk_menu_new (); bilinear1 = gtk_menu_item_new_with_mnemonic (_("Bilinear")); gtk_widget_show (bilinear1); gtk_container_add (GTK_CONTAINER (menu3), bilinear1); bicubic1 = gtk_menu_item_new_with_mnemonic (_("Bicubic")); gtk_widget_show (bicubic1); gtk_container_add (GTK_CONTAINER (menu3), bicubic1); lanczos1 = gtk_menu_item_new_with_mnemonic (_("Lanczos3")); gtk_widget_show (lanczos1); gtk_container_add (GTK_CONTAINER (menu3), lanczos1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu3); hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (100, 0, 200, 1, 1, 0))); gtk_widget_show (hscale1); gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0); gtk_scale_set_digits (GTK_SCALE (hscale1), 0); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); applybutton1 = gtk_button_new_from_stock ("gtk-apply"); gtk_widget_show (applybutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), applybutton1, GTK_RESPONSE_APPLY); GTK_WIDGET_SET_FLAGS (applybutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, table1, "table1"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT (dialog1, entry_width, "entry_width"); GLADE_HOOKUP_OBJECT (dialog1, entry_height, "entry_height"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label_errorx, "label_errorx"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, label_errory, "label_errory"); GLADE_HOOKUP_OBJECT (dialog1, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, hseparator1, "hseparator1"); GLADE_HOOKUP_OBJECT (dialog1, vbox3, "vbox3"); GLADE_HOOKUP_OBJECT (dialog1, optionmenu_source, "optionmenu_source"); GLADE_HOOKUP_OBJECT (dialog1, menu1, "menu1"); GLADE_HOOKUP_OBJECT (dialog1, item1_1, "item1_1"); GLADE_HOOKUP_OBJECT (dialog1, _4_1, "_4_1"); GLADE_HOOKUP_OBJECT (dialog1, _16_1, "_16_1"); GLADE_HOOKUP_OBJECT (dialog1, optionmenu_dest, "optionmenu_dest"); GLADE_HOOKUP_OBJECT (dialog1, menu2, "menu2"); GLADE_HOOKUP_OBJECT (dialog1, menuitem1, "menuitem1"); GLADE_HOOKUP_OBJECT (dialog1, menuitem2, "menuitem2"); GLADE_HOOKUP_OBJECT (dialog1, menuitem3, "menuitem3"); GLADE_HOOKUP_OBJECT (dialog1, checkbutton_16, "checkbutton_16"); GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1"); GLADE_HOOKUP_OBJECT (dialog1, menu3, "menu3"); GLADE_HOOKUP_OBJECT (dialog1, bilinear1, "bilinear1"); GLADE_HOOKUP_OBJECT (dialog1, bicubic1, "bicubic1"); GLADE_HOOKUP_OBJECT (dialog1, lanczos1, "lanczos1"); GLADE_HOOKUP_OBJECT (dialog1, hscale1, "hscale1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, applybutton1, "applybutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }
static gboolean cwt_dialog(CWTArgs *args) { GtkWidget *dialog, *table; CWTControls controls; enum { RESPONSE_RESET = 1 }; gint response; dialog = gtk_dialog_new_with_buttons(_("2D CWT"), NULL, 0, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); table = gtk_table_new(4, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, FALSE, FALSE, 4); controls.scale = gtk_adjustment_new(args->scale, 0.0, 1000.0, 1, 10, 0); gwy_table_attach_spinbutton(table, 1, _("_Scale:"), _("pixels"), controls.scale); controls.preserve = gtk_check_button_new_with_mnemonic(_("_Preserve size (don't " "resize to power of 2)")); gtk_table_attach(GTK_TABLE(table), controls.preserve, 0, 3, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.preserve), args->preserve); g_signal_connect(controls.preserve, "toggled", G_CALLBACK(preserve_changed_cb), args); controls.interp = gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1, G_CALLBACK(gwy_enum_combo_box_update_int), &args->interp, args->interp, TRUE); gwy_table_attach_row(table, 2, _("_Interpolation type:"), "", controls.interp); controls.wavelet = gwy_enum_combo_box_new(gwy_2d_cwt_wavelet_type_get_enum(), -1, G_CALLBACK(gwy_enum_combo_box_update_int), &args->wavelet, args->wavelet, TRUE); gwy_table_attach_row(table, 3, _("_Wavelet type:"), "", controls.wavelet); gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: args->scale = gtk_adjustment_get_value(GTK_ADJUSTMENT(controls.scale)); gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: *args = cwt_defaults; cwt_dialog_update(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); args->scale = gtk_adjustment_get_value(GTK_ADJUSTMENT(controls.scale)); gtk_widget_destroy(dialog); return TRUE; }