void procdialog_create_renice_dialog (ProcData *procdata) { ProcInfo *info = procdata->selected_process; GtkWidget *dialog = NULL; GtkWidget *dialog_vbox; GtkWidget *vbox; GtkWidget *label; GtkWidget *priority_label; GtkWidget *grid; GtkAdjustment *renice_adj; GtkWidget *hscale; GtkWidget *button; GtkWidget *icon; gchar *text; gchar *dialog_title; if (renice_dialog) return; if (!info) return; dialog_title = g_strdup_printf (_("Change Priority of Process “%s” (PID: %u)"), info->name, info->pid); dialog = gtk_dialog_new_with_buttons (dialog_title, NULL, GTK_DIALOG_DESTROY_WITH_PARENT, "gtk-cancel", GTK_RESPONSE_CANCEL, NULL); g_free (dialog_title); renice_dialog = dialog; gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE); gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5); button = gtk_button_new_with_mnemonic (_("Change _Priority")); gtk_widget_set_can_default (button, TRUE); icon = gtk_image_new_from_stock ("gtk-ok", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (button), icon); gtk_dialog_add_action_widget (GTK_DIALOG (renice_dialog), button, 100); gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100); new_nice_value = -100; dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2); gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_box_pack_start (GTK_BOX (dialog_vbox), vbox, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID(grid), 12); gtk_grid_set_row_spacing (GTK_GRID(grid), 6); gtk_box_pack_start (GTK_BOX (vbox), grid, TRUE, TRUE, 0); label = gtk_label_new_with_mnemonic (_("_Nice value:")); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 2); renice_adj = gtk_adjustment_new (info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0); new_nice_value = 0; hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, renice_adj); gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale); gtk_scale_set_digits (GTK_SCALE (hscale), 0); gtk_widget_set_hexpand (hscale, TRUE); gtk_grid_attach (GTK_GRID (grid), hscale, 1, 0, 1, 1); text = g_strdup_printf(_("(%s Priority)"), procman::get_nice_level (info->nice)); priority_label = gtk_label_new (text); gtk_grid_attach (GTK_GRID (grid), priority_label, 1, 1, 1, 1); g_free(text); text = g_strconcat("<small><i><b>", _("Note:"), "</b> ", _("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."), "</i></small>", NULL); label = gtk_label_new (_(text)); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); g_free (text); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (renice_dialog_button_pressed), procdata); g_signal_connect (G_OBJECT (renice_adj), "value_changed", G_CALLBACK (renice_scale_changed), priority_label); gtk_widget_show_all (dialog); }
void wxStaticText::GTKWidgetDoSetMnemonic(GtkWidget* w) { gtk_label_set_mnemonic_widget(GTK_LABEL(m_widget), w); }
void wxControl::GTKFrameSetMnemonicWidget(GtkFrame* w, GtkWidget* widget) { GtkLabel* labelwidget = GTK_LABEL(gtk_frame_get_label_widget(w)); gtk_label_set_mnemonic_widget(labelwidget, widget); }
static void brasero_split_dialog_init (BraseroSplitDialog *object) { gchar *title; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *vbox2; GtkWidget *hbox2; GtkWidget *label; GtkWidget *scroll; GtkWidget *button; GtkTreeModel *model; GtkSizeGroup *size_group; GtkCellRenderer *renderer; GtkTreeViewColumn *column; BraseroSplitDialogPrivate *priv; priv = BRASERO_SPLIT_DIALOG_PRIVATE (object); gtk_window_set_title (GTK_WINDOW (object), _("Split Track")); gtk_window_set_default_size (GTK_WINDOW (object), 500, 600); gtk_dialog_add_button (GTK_DIALOG (object), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (object), GTK_STOCK_OK, GTK_RESPONSE_OK); vbox = gtk_dialog_get_content_area (GTK_DIALOG (object)); gtk_box_set_spacing (GTK_BOX (vbox), 0); size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH); /* Slicing method */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_show (hbox); priv->combo = gtk_combo_box_text_new (); label = gtk_label_new_with_mnemonic (_("M_ethod:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->combo); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_set_tooltip_text (priv->combo, _("Method to be used to split the track")); gtk_widget_show (priv->combo); gtk_box_pack_start (GTK_BOX (hbox), priv->combo, TRUE, TRUE, 0); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (priv->combo), _("Split track manually")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (priv->combo), _("Split track in parts with a fixed length")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (priv->combo), _("Split track in a fixed number of parts")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (priv->combo), _("Split track for each silence")); g_signal_connect (priv->combo, "changed", G_CALLBACK (brasero_split_dialog_combo_changed_cb), object); button = brasero_utils_make_button (_("_Slice"), NULL, "transform-crop-and-resize", GTK_ICON_SIZE_BUTTON); gtk_widget_show (button); gtk_size_group_add_widget (size_group, button); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (brasero_split_dialog_cut_clicked_cb), object); gtk_widget_set_tooltip_text (button, _("Add a splitting point")); priv->cut = button; priv->notebook = gtk_notebook_new (); gtk_widget_show (priv->notebook); gtk_notebook_set_show_border (GTK_NOTEBOOK (priv->notebook), FALSE); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (priv->notebook), FALSE); priv->player = brasero_song_control_new (); gtk_widget_show (priv->player); gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), priv->player, NULL); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_show (hbox2); gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), hbox2, NULL); /* Translators: this goes with the next (= "seconds") */ label = gtk_label_new (_("Split this track every")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); priv->spin_sec = gtk_spin_button_new_with_range (1.0, 1000.0, 1.0); gtk_widget_show (priv->spin_sec); gtk_box_pack_start (GTK_BOX (hbox2), priv->spin_sec, FALSE, FALSE, 0); /* Translators: this goes with the previous (= "Split track every") */ label = gtk_label_new (_("seconds")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_show (hbox2); gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), hbox2, NULL); /* Translators: this goes with the next (= "parts") */ label = gtk_label_new (_("Split this track in")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); priv->spin_parts = gtk_spin_button_new_with_range (2.0, 1000.0, 1.0); gtk_widget_show (priv->spin_parts); gtk_box_pack_start (GTK_BOX (hbox2), priv->spin_parts, FALSE, FALSE, 0); /* Translators: this goes with the previous (= "Split this track in") */ label = gtk_label_new (_("parts")); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); priv->silence_label = gtk_label_new (NULL); gtk_widget_show (priv->silence_label); gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), priv->silence_label, NULL); title = g_strdup_printf ("<b>%s</b>", _("Slicing Method")); gtk_box_pack_start (GTK_BOX (vbox), brasero_utils_pack_properties (title, priv->notebook, hbox, NULL), FALSE, FALSE, 0); g_free (title); /* slices preview */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_widget_show (hbox); priv->model = gtk_list_store_new (COLUMN_NUM, G_TYPE_INT64, G_TYPE_INT64, G_TYPE_INT64, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); g_signal_connect (priv->model, "row-inserted", G_CALLBACK (brasero_split_dialog_row_inserted_cb), object); g_signal_connect (priv->model, "row-deleted", G_CALLBACK (brasero_split_dialog_row_deleted_cb), object); model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (priv->model)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), START_COL, GTK_SORT_ASCENDING); scroll = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (scroll); gtk_box_pack_start (GTK_BOX (hbox), scroll, TRUE, TRUE, 0); priv->tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_enable_tree_lines (GTK_TREE_VIEW (priv->tree), TRUE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->tree), TRUE); gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (priv->tree), TRUE); gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree)), GTK_SELECTION_MULTIPLE); gtk_widget_show (priv->tree); gtk_container_add (GTK_CONTAINER (scroll), priv->tree); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Start"), renderer, "text", START_STR_COL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("End"), renderer, "text", END_STR_COL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Length"), renderer, "text", LENGTH_STR_COL, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree), column); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree)), "changed", G_CALLBACK (brasero_split_dialog_selection_changed_cb), object); /* buttons */ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_widget_show (vbox2); gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, TRUE, 0); button = brasero_utils_make_button (_("Mer_ge"), NULL, NULL, GTK_ICON_SIZE_BUTTON); gtk_widget_show (button); gtk_size_group_add_widget (size_group, button); gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (brasero_split_dialog_merge_clicked_cb), object); gtk_widget_set_tooltip_text (button, _("Merge a selected slice with the next selected one")); priv->merge_button = button; button = brasero_utils_make_button (_("_Remove"), GTK_STOCK_REMOVE, NULL, GTK_ICON_SIZE_BUTTON); gtk_widget_show (button); gtk_size_group_add_widget (size_group, button); gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (brasero_split_dialog_remove_clicked_cb), object); gtk_widget_set_tooltip_text (button, _("Remove the selected slices")); priv->remove_button = button; button = brasero_utils_make_button (_("Re_move All"), NULL, NULL, GTK_ICON_SIZE_BUTTON); gtk_widget_show (button); gtk_size_group_add_widget (size_group, button); gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (brasero_split_dialog_reset_clicked_cb), object); gtk_widget_set_tooltip_text (button, _("Clear the slices preview")); priv->reset_button = button; gtk_widget_set_sensitive (priv->reset_button, FALSE); gtk_widget_set_sensitive (priv->merge_button, FALSE); gtk_widget_set_sensitive (priv->remove_button, FALSE); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_widget_show (vbox2); label = gtk_label_new_with_mnemonic (_("_List of slices that are to be created:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->tree); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), hbox, TRUE, TRUE, 0); title = g_strdup_printf ("<b>%s</b>", _("Slices Preview")); gtk_box_pack_start (GTK_BOX (vbox), brasero_utils_pack_properties (title, vbox2, NULL), TRUE, TRUE, 0); g_free (title); gtk_combo_box_set_active (GTK_COMBO_BOX (priv->combo), 0); g_object_unref (size_group); }
static void wifi_private_init (CEPageWifi *self) { CEPageWifiPrivate *priv = CE_PAGE_WIFI_GET_PRIVATE (self); GtkBuilder *builder; GtkWidget *widget; GtkWidget *align; GtkLabel *label; builder = CE_PAGE (self)->builder; priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->ssid = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_ssid"))); priv->cloned_mac = GTK_ENTRY (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_cloned_mac"))); priv->mode = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_mode"))); priv->band = GTK_COMBO_BOX (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_band"))); priv->channel = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_channel"))); /* BSSID */ #if GTK_CHECK_VERSION(2,24,0) priv->bssid = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->bssid), 0); #else priv->bssid = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->bssid), 0); #endif gtk_widget_set_tooltip_text (GTK_WIDGET (priv->bssid), _("This option locks this connection to the Wi-Fi access point (AP) specified by the BSSID entered here. Example: 00:11:22:33:44:55")); align = GTK_WIDGET (gtk_builder_get_object (builder, "wifi_bssid_alignment")); gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->bssid)); gtk_widget_show_all (GTK_WIDGET (priv->bssid)); /* Device MAC */ #if GTK_CHECK_VERSION(2,24,0) priv->device_mac = GTK_COMBO_BOX_TEXT (gtk_combo_box_text_new_with_entry ()); gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (priv->device_mac), 0); #else priv->device_mac = GTK_COMBO_BOX_ENTRY (gtk_combo_box_entry_new_text ()); gtk_combo_box_entry_set_text_column (GTK_COMBO_BOX_ENTRY (priv->device_mac), 0); #endif gtk_widget_set_tooltip_text (GTK_WIDGET (priv->device_mac), _("This option locks this connection to the network device specified by its permanent MAC address entered here. Example: 00:11:22:33:44:55")); align = GTK_WIDGET (gtk_builder_get_object (builder, "wifi_device_mac_alignment")); gtk_container_add (GTK_CONTAINER (align), GTK_WIDGET (priv->device_mac)); gtk_widget_show_all (GTK_WIDGET (priv->device_mac)); /* Set mnemonic widget for device MAC label */ label = GTK_LABEL (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_device_mac_label"))); gtk_label_set_mnemonic_widget (label, GTK_WIDGET (priv->device_mac)); priv->rate = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_rate"))); widget = GTK_WIDGET (gtk_builder_get_object (builder, "rate_units")); gtk_size_group_add_widget (priv->group, widget); priv->tx_power = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_tx_power"))); widget = GTK_WIDGET (gtk_builder_get_object (builder, "tx_power_units")); gtk_size_group_add_widget (priv->group, widget); priv->mtu = GTK_SPIN_BUTTON (GTK_WIDGET (gtk_builder_get_object (builder, "wifi_mtu"))); widget = GTK_WIDGET (gtk_builder_get_object (builder, "mtu_units")); gtk_size_group_add_widget (priv->group, widget); }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *frame1; GtkWidget *table2; GtkWidget *label4; GtkWidget *label5; GtkWidget *hscaleBrightness; GtkWidget *hscaleSaturation; GtkWidget *hscaleContrast; GtkWidget *label3; GtkWidget *label1; GtkWidget *frame2; GtkWidget *table3; GtkWidget *label6; GtkWidget *hscaleGamma; GtkWidget *hscaleGammaR; GtkWidget *label8; GtkWidget *hscaleGammaG; GtkWidget *label9; GtkWidget *label10; GtkWidget *label7; GtkWidget *hscaleGammaB; GtkWidget *hscaleGammaWeight; GtkWidget *label2; GtkWidget *hscale1; GtkWidget *drawingarea1; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("MPlayer eq2")); gtk_window_set_resizable (GTK_WINDOW (dialog1), FALSE); 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, FALSE, FALSE, 0); frame1 = gtk_frame_new (NULL); gtk_widget_show (frame1); gtk_box_pack_start (GTK_BOX (hbox1), frame1, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE); table2 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (frame1), table2); gtk_container_set_border_width (GTK_CONTAINER (table2), 12); gtk_table_set_row_spacings (GTK_TABLE (table2), 6); gtk_table_set_col_spacings (GTK_TABLE (table2), 12); label4 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Brigh_tness:")); gtk_widget_show (label4); gtk_table_attach (GTK_TABLE (table2), label4, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5); label5 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Saturation:")); gtk_widget_show (label5); gtk_table_attach (GTK_TABLE (table2), label5, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5); hscaleBrightness = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, -1, 1, 0.05, 1, 0))); gtk_widget_show (hscaleBrightness); gtk_table_attach (GTK_TABLE (table2), hscaleBrightness, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleBrightness, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleBrightness), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleBrightness), 2); hscaleSaturation = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 3, 0.05, 1, 0))); gtk_widget_show (hscaleSaturation); gtk_table_attach (GTK_TABLE (table2), hscaleSaturation, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleSaturation, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleSaturation), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleSaturation), 2); hscaleContrast = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, -2, 2, 0.05, 1, 0))); gtk_widget_show (hscaleContrast); gtk_table_attach (GTK_TABLE (table2), hscaleContrast, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleContrast, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleContrast), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleContrast), 2); label3 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Contrast:")); gtk_widget_show (label3); gtk_table_attach (GTK_TABLE (table2), label3, 0, 1, 0, 1, (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); label1 = gtk_label_new (""); gtk_widget_show (label1); gtk_frame_set_label_widget (GTK_FRAME (frame1), label1); gtk_label_set_use_markup (GTK_LABEL (label1), TRUE); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); frame2 = gtk_frame_new (NULL); gtk_widget_show (frame2); gtk_box_pack_start (GTK_BOX (hbox1), frame2, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE); table3 = gtk_table_new (5, 2, FALSE); gtk_widget_show (table3); gtk_container_add (GTK_CONTAINER (frame2), table3); gtk_container_set_border_width (GTK_CONTAINER (table3), 12); gtk_table_set_row_spacings (GTK_TABLE (table3), 6); gtk_table_set_col_spacings (GTK_TABLE (table3), 12); label6 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Initial:")); gtk_widget_show (label6); gtk_table_attach (GTK_TABLE (table3), label6, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5); hscaleGamma = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGamma); gtk_table_attach (GTK_TABLE (table3), hscaleGamma, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGamma, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGamma), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGamma), 2); hscaleGammaR = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaR); gtk_table_attach (GTK_TABLE (table3), hscaleGammaR, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaR, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaR), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaR), 2); label8 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Red:")); gtk_widget_show (label8); gtk_table_attach (GTK_TABLE (table3), label8, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label8), 0, 0.5); hscaleGammaG = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaG); gtk_table_attach (GTK_TABLE (table3), hscaleGammaG, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaG, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaG), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaG), 2); label9 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Green:")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); label10 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Blue:")); gtk_widget_show (label10); gtk_table_attach (GTK_TABLE (table3), label10, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label10), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label10), 0, 0.5); label7 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Weight:")); gtk_widget_show (label7); gtk_table_attach (GTK_TABLE (table3), label7, 0, 1, 4, 5, (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); hscaleGammaB = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0.1, 3, 0.05, 1, 0))); gtk_widget_show (hscaleGammaB); gtk_table_attach (GTK_TABLE (table3), hscaleGammaB, 1, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaB, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaB), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaB), 2); hscaleGammaWeight = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 1, 0.05, 1, 0))); gtk_widget_show (hscaleGammaWeight); gtk_table_attach (GTK_TABLE (table3), hscaleGammaWeight, 1, 2, 4, 5, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_widget_set_size_request (hscaleGammaWeight, 144, 0); gtk_scale_set_value_pos (GTK_SCALE (hscaleGammaWeight), GTK_POS_RIGHT); gtk_scale_set_digits (GTK_SCALE (hscaleGammaWeight), 2); label2 = gtk_label_new (QT_TR_NOOP("<b>Gamma</b>")); gtk_widget_show (label2); gtk_frame_set_label_widget (GTK_FRAME (frame2), label2); gtk_label_set_use_markup (GTK_LABEL (label2), TRUE); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 1, 0))); gtk_widget_show (hscale1); gtk_box_pack_start (GTK_BOX (vbox1), hscale1, FALSE, FALSE, 0); drawingarea1 = gtk_drawing_area_new (); gtk_widget_show (drawingarea1); gtk_box_pack_start (GTK_BOX (vbox1), drawingarea1, TRUE, TRUE, 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); gtk_label_set_mnemonic_widget (GTK_LABEL (label4), hscaleBrightness); gtk_label_set_mnemonic_widget (GTK_LABEL (label5), hscaleSaturation); gtk_label_set_mnemonic_widget (GTK_LABEL (label3), hscaleContrast); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), hscaleGamma); gtk_label_set_mnemonic_widget (GTK_LABEL (label8), hscaleGammaR); gtk_label_set_mnemonic_widget (GTK_LABEL (label9), hscaleGammaG); gtk_label_set_mnemonic_widget (GTK_LABEL (label10), hscaleGammaB); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), hscaleGammaWeight); /* 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, frame1, "frame1"); GLADE_HOOKUP_OBJECT (dialog1, table2, "table2"); GLADE_HOOKUP_OBJECT (dialog1, label4, "label4"); GLADE_HOOKUP_OBJECT (dialog1, label5, "label5"); GLADE_HOOKUP_OBJECT (dialog1, hscaleBrightness, "hscaleBrightness"); GLADE_HOOKUP_OBJECT (dialog1, hscaleSaturation, "hscaleSaturation"); GLADE_HOOKUP_OBJECT (dialog1, hscaleContrast, "hscaleContrast"); GLADE_HOOKUP_OBJECT (dialog1, label3, "label3"); GLADE_HOOKUP_OBJECT (dialog1, label1, "label1"); GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2"); GLADE_HOOKUP_OBJECT (dialog1, table3, "table3"); GLADE_HOOKUP_OBJECT (dialog1, label6, "label6"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGamma, "hscaleGamma"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaR, "hscaleGammaR"); GLADE_HOOKUP_OBJECT (dialog1, label8, "label8"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaG, "hscaleGammaG"); GLADE_HOOKUP_OBJECT (dialog1, label9, "label9"); GLADE_HOOKUP_OBJECT (dialog1, label10, "label10"); GLADE_HOOKUP_OBJECT (dialog1, label7, "label7"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaB, "hscaleGammaB"); GLADE_HOOKUP_OBJECT (dialog1, hscaleGammaWeight, "hscaleGammaWeight"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); 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 PanelAddtoDialog * panel_addto_dialog_new (PanelWidget *panel_widget) { PanelAddtoDialog *dialog; GtkWidget *dialog_vbox; GtkWidget *inner_vbox; GtkWidget *find_hbox; GtkWidget *sw; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; dialog = g_new0 (PanelAddtoDialog, 1); g_object_set_qdata_full (G_OBJECT (panel_widget->toplevel), panel_addto_dialog_quark, dialog, (GDestroyNotify) panel_addto_dialog_free); dialog->panel_widget = panel_widget; g_signal_connect (dialog->panel_widget->toplevel->settings, "changed::" PANEL_TOPLEVEL_NAME_KEY, G_CALLBACK (panel_addto_name_notify), dialog); dialog->addto_dialog = gtk_dialog_new (); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_HELP, GTK_RESPONSE_HELP); dialog->back_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_GO_BACK, PANEL_ADDTO_RESPONSE_BACK); dialog->add_button = gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_ADD, PANEL_ADDTO_RESPONSE_ADD); gtk_dialog_add_button (GTK_DIALOG (dialog->addto_dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_widget_set_sensitive (GTK_WIDGET (dialog->add_button), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (dialog->addto_dialog), PANEL_ADDTO_RESPONSE_ADD); gtk_container_set_border_width (GTK_CONTAINER (dialog->addto_dialog), 5); dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog->addto_dialog)); gtk_box_set_spacing (GTK_BOX (dialog_vbox), 12); gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5); g_signal_connect (G_OBJECT (dialog->addto_dialog), "response", G_CALLBACK (panel_addto_dialog_response), dialog); g_signal_connect (dialog->addto_dialog, "destroy", G_CALLBACK (panel_addto_dialog_destroy), dialog); inner_vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (dialog_vbox), inner_vbox, TRUE, TRUE, 0); find_hbox = gtk_hbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (inner_vbox), find_hbox, FALSE, FALSE, 0); dialog->label = gtk_label_new_with_mnemonic (""); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (dialog->label), 0.0); gtk_label_set_yalign (GTK_LABEL (dialog->label), 0.5); #else gtk_misc_set_alignment (GTK_MISC (dialog->label), 0.0, 0.5); #endif gtk_label_set_use_markup (GTK_LABEL (dialog->label), TRUE); gtk_box_pack_start (GTK_BOX (find_hbox), dialog->label, FALSE, FALSE, 0); dialog->search_entry = gtk_entry_new (); g_signal_connect (G_OBJECT (dialog->search_entry), "changed", G_CALLBACK (panel_addto_search_entry_changed), dialog); g_signal_connect (G_OBJECT (dialog->search_entry), "activate", G_CALLBACK (panel_addto_search_entry_activated), dialog); gtk_box_pack_end (GTK_BOX (find_hbox), dialog->search_entry, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (dialog->label), dialog->search_entry); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (inner_vbox), sw, TRUE, TRUE, 0); dialog->tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view), FALSE); gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tree_view)); renderer = g_object_new (GTK_TYPE_CELL_RENDERER_PIXBUF, "xpad", 4, "ypad", 4, "stock-size", panel_add_to_icon_get_size(), NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "icon_name", COLUMN_ICON_NAME, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (dialog->tree_view), -1, NULL, renderer, "markup", COLUMN_TEXT, NULL); //FIXME use the same search than the one for the search entry? gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_SEARCH); gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (dialog->tree_view), panel_addto_separator_func, GINT_TO_POINTER (COLUMN_TEXT), NULL); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->tree_view), COLUMN_TEXT); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); g_signal_connect (selection, "changed", G_CALLBACK (panel_addto_selection_changed), dialog); g_signal_connect (dialog->tree_view, "row-activated", G_CALLBACK (panel_addto_selection_activated), dialog); gtk_container_add (GTK_CONTAINER (sw), dialog->tree_view); gtk_widget_show_all (dialog_vbox); panel_toplevel_push_autohide_disabler (dialog->panel_widget->toplevel); panel_widget_register_open_dialog (panel_widget, dialog->addto_dialog); panel_addto_name_change (dialog, panel_toplevel_get_name (dialog->panel_widget->toplevel)); return dialog; }
static void egg_find_bar_init (EggFindBar *find_bar) { EggFindBarPrivate *priv; GtkWidget *label; GtkWidget *alignment; GtkWidget *box; GtkToolItem *item; GtkWidget *arrow; /* Data */ priv = EGG_FIND_BAR_GET_PRIVATE (find_bar); find_bar->priv = priv; priv->search_string = NULL; gtk_toolbar_set_style (GTK_TOOLBAR (find_bar), GTK_TOOLBAR_BOTH_HORIZ); /* Find: |_____| */ item = gtk_tool_item_new (); box = gtk_hbox_new (FALSE, 12); alignment = gtk_alignment_new (0.0, 0.5, 1.0, 0.0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 2, 2); label = gtk_label_new_with_mnemonic (_("Find:")); priv->find_entry = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (priv->find_entry), 32); gtk_entry_set_max_length (GTK_ENTRY (priv->find_entry), 512); gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->find_entry); /* Prev */ arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE); priv->previous_button = gtk_tool_button_new (arrow, Q_("Find Pre_vious")); gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (priv->previous_button), TRUE); gtk_tool_item_set_is_important (priv->previous_button, TRUE); gtk_widget_set_tooltip_text (GTK_WIDGET (priv->previous_button), _("Find previous occurrence of the search string")); /* Next */ arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE); priv->next_button = gtk_tool_button_new (arrow, Q_("Find Ne_xt")); gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (priv->next_button), TRUE); gtk_tool_item_set_is_important (priv->next_button, TRUE); gtk_widget_set_tooltip_text (GTK_WIDGET (priv->next_button), _("Find next occurrence of the search string")); /* Separator*/ priv->status_separator = gtk_separator_tool_item_new(); /* Case button */ priv->case_button = gtk_toggle_tool_button_new (); g_object_set (G_OBJECT (priv->case_button), "label", _("C_ase Sensitive"), NULL); gtk_tool_item_set_is_important (priv->case_button, TRUE); gtk_widget_set_tooltip_text (GTK_WIDGET (priv->case_button), _("Toggle case sensitive search")); /* Status */ priv->status_item = gtk_tool_item_new(); gtk_tool_item_set_expand (priv->status_item, TRUE); priv->status_label = gtk_label_new (NULL); gtk_label_set_ellipsize (GTK_LABEL (priv->status_label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC (priv->status_label), 0.0, 0.5); g_signal_connect (priv->find_entry, "changed", G_CALLBACK (entry_changed_callback), find_bar); g_signal_connect (priv->find_entry, "activate", G_CALLBACK (entry_activate_callback), find_bar); g_signal_connect (priv->next_button, "clicked", G_CALLBACK (next_clicked_callback), find_bar); g_signal_connect (priv->previous_button, "clicked", G_CALLBACK (previous_clicked_callback), find_bar); g_signal_connect (priv->case_button, "toggled", G_CALLBACK (case_sensitive_toggled_callback), find_bar); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box), priv->find_entry, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (alignment), box); gtk_container_add (GTK_CONTAINER (item), alignment); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), item, -1); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->previous_button, -1); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->next_button, -1); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->case_button, -1); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_separator, -1); gtk_container_add (GTK_CONTAINER (priv->status_item), priv->status_label); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_item, -1); /* don't show status separator/label until they are set */ gtk_widget_show_all (GTK_WIDGET (item)); gtk_widget_show_all (GTK_WIDGET (priv->next_button)); gtk_widget_show_all (GTK_WIDGET (priv->previous_button)); gtk_widget_show (priv->status_label); }
WindowMerge::WindowMerge(GtkWidget * parent_layout, GtkAccelGroup *accelerator_group, bool startup): FloatingWindow(parent_layout, widMerge, _("Merge"), startup) // Window for merging changes. { // Save and initialize variables. load_gui_event_id = 0; editors_changed_event_id = 0; // Build GUI. notebook1 = gtk_notebook_new(); gtk_widget_show(notebook1); gtk_container_add(GTK_CONTAINER(vbox_client), notebook1); gtk_notebook_set_show_tabs(GTK_NOTEBOOK(notebook1), FALSE); // Build merge GUI. vbox1 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox1); gtk_container_add(GTK_CONTAINER(notebook1), vbox1); label6 = gtk_label_new_with_mnemonic(_("M_aster project")); gtk_widget_show(label6); gtk_box_pack_start(GTK_BOX(vbox1), label6, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label6), 0, 0.5); combobox_master = gtk_combo_box_new_text(); gtk_widget_show(combobox_master); gtk_box_pack_start(GTK_BOX(vbox1), combobox_master, FALSE, FALSE, 0); connect_focus_signals (combobox_master); label7 = gtk_label_new_with_mnemonic(_("E_dited project")); gtk_widget_show(label7); gtk_box_pack_start(GTK_BOX(vbox1), label7, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label7), 0, 0.5); combobox_edited = gtk_combo_box_new_text(); gtk_widget_show(combobox_edited); gtk_box_pack_start(GTK_BOX(vbox1), combobox_edited, FALSE, FALSE, 0); connect_focus_signals (combobox_edited); label_info = gtk_label_new(""); gtk_widget_show(label_info); gtk_box_pack_start(GTK_BOX(vbox1), label_info, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label_info), 0, 0.5); display_changes_gui = new DisplayChangesGui (vbox1); connect_focus_signals (display_changes_gui->textview); hbox1 = gtk_hbox_new(FALSE, 0); gtk_widget_show(hbox1); gtk_box_pack_start(GTK_BOX(vbox1), hbox1, FALSE, FALSE, 0); button_previous = gtk_button_new(); gtk_widget_show(button_previous); gtk_box_pack_start(GTK_BOX(hbox1), button_previous, FALSE, FALSE, 0); connect_focus_signals (button_previous); alignment2 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment2); gtk_container_add(GTK_CONTAINER(button_previous), alignment2); hbox2 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox2); gtk_container_add(GTK_CONTAINER(alignment2), hbox2); image6 = gtk_image_new_from_stock("gtk-go-back", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image6); gtk_box_pack_start(GTK_BOX(hbox2), image6, FALSE, FALSE, 0); label9 = gtk_label_new_with_mnemonic(_("_Previous")); gtk_widget_show(label9); gtk_box_pack_start(GTK_BOX(hbox2), label9, FALSE, FALSE, 0); button_merge = gtk_button_new(); gtk_widget_show(button_merge); gtk_box_pack_start(GTK_BOX(hbox1), button_merge, TRUE, TRUE, 0); connect_focus_signals (button_merge); alignment1 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment1); gtk_container_add(GTK_CONTAINER(button_merge), alignment1); hbox4 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox4); gtk_container_add(GTK_CONTAINER(alignment1), hbox4); image5 = gtk_image_new_from_stock("gtk-refresh", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image5); gtk_box_pack_start(GTK_BOX(hbox4), image5, FALSE, FALSE, 0); label8 = gtk_label_new_with_mnemonic(_("_Merge")); gtk_widget_show(label8); gtk_box_pack_start(GTK_BOX(hbox4), label8, FALSE, FALSE, 0); button_next = gtk_button_new(); gtk_widget_show(button_next); gtk_box_pack_start(GTK_BOX(hbox1), button_next, FALSE, FALSE, 0); connect_focus_signals (button_next); alignment3 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment3); gtk_container_add(GTK_CONTAINER(button_next), alignment3); hbox3 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox3); gtk_container_add(GTK_CONTAINER(alignment3), hbox3); label10 = gtk_label_new_with_mnemonic(_("_Next")); gtk_widget_show(label10); gtk_box_pack_start(GTK_BOX(hbox3), label10, FALSE, FALSE, 0); image8 = gtk_image_new_from_stock("gtk-go-forward", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image8); gtk_box_pack_start(GTK_BOX(hbox3), image8, FALSE, FALSE, 0); // Build approve GUI. vbox2 = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox2); gtk_container_add(GTK_CONTAINER(notebook1), vbox2); label_approve = gtk_label_new(""); gtk_widget_show(label_approve); gtk_box_pack_start(GTK_BOX(vbox2), label_approve, FALSE, FALSE, 0); gtk_misc_set_alignment(GTK_MISC(label_approve), 0, 0.5); scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow2); gtk_box_pack_start(GTK_BOX(vbox2), scrolledwindow2, TRUE, TRUE, 0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_SHADOW_IN); textview_approval = gtk_text_view_new(); gtk_widget_show(textview_approval); gtk_container_add(GTK_CONTAINER(scrolledwindow2), textview_approval); gtk_text_view_set_editable(GTK_TEXT_VIEW(textview_approval), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview_approval), GTK_WRAP_WORD); gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(textview_approval), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textview_approval), FALSE); connect_focus_signals (textview_approval); approve_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_approval)); button_ready = gtk_button_new(); gtk_widget_show(button_ready); gtk_box_pack_start(GTK_BOX(vbox2), button_ready, FALSE, FALSE, 0); connect_focus_signals (button_ready); alignment6 = gtk_alignment_new(0.5, 0.5, 0, 0); gtk_widget_show(alignment6); gtk_container_add(GTK_CONTAINER(button_ready), alignment6); hbox7 = gtk_hbox_new(FALSE, 2); gtk_widget_show(hbox7); gtk_container_add(GTK_CONTAINER(alignment6), hbox7); image11 = gtk_image_new_from_stock("gtk-ok", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image11); gtk_box_pack_start(GTK_BOX(hbox7), image11, FALSE, FALSE, 0); label19 = gtk_label_new_with_mnemonic(_("_Save")); gtk_widget_show(label19); gtk_box_pack_start(GTK_BOX(hbox7), label19, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget(GTK_LABEL(label6), combobox_master); gtk_label_set_mnemonic_widget(GTK_LABEL(label7), combobox_edited); g_signal_connect((gpointer) combobox_master, "changed", G_CALLBACK(on_combobox_master_changed), gpointer(this)); g_signal_connect((gpointer) combobox_edited, "changed", G_CALLBACK(on_combobox_edited_changed), gpointer(this)); g_signal_connect((gpointer) button_previous, "clicked", G_CALLBACK(on_button_previous_clicked), gpointer(this)); g_signal_connect((gpointer) button_merge, "clicked", G_CALLBACK(on_button_merge_clicked), gpointer(this)); g_signal_connect((gpointer) button_next, "clicked", G_CALLBACK(on_button_next_clicked), gpointer(this)); g_signal_connect((gpointer) button_ready, "clicked", G_CALLBACK(on_button_ready_clicked), gpointer(this)); // Create signalling buttons. editors_get_text_button = gtk_button_new(); new_reference_button = gtk_button_new(); save_editors_button = gtk_button_new(); reload_editors_button = gtk_button_new(); // Set buttons insensitive. gtk_widget_set_sensitive(button_previous, false); gtk_widget_set_sensitive(button_merge, false); gtk_widget_set_sensitive(button_next, false); // Main focused widget. last_focused_widget = combobox_master; gtk_widget_grab_focus (last_focused_widget); }
static void add_route_row (CEPageIP4 *page, const gchar *address, const gchar *netmask, const gchar *gateway, gint metric) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *label; GtkWidget *widget; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Netmask")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "netmask", widget); gtk_entry_set_text (GTK_ENTRY (widget), netmask); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); /* Translators: Please see https://en.wikipedia.org/wiki/Metrics_(networking) */ label = gtk_label_new (C_("network parameters", "Metric")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 4, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "metric", widget); if (metric > 0) { gchar *s = g_strdup_printf ("%d", metric); gtk_entry_set_text (GTK_ENTRY (widget), s); g_free (s); } gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 4, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Route")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_widget_set_halign (delete_button, GTK_ALIGN_CENTER); gtk_widget_set_valign (delete_button, GTK_ALIGN_CENTER); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 1, 1, 4); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_start (row_grid, 10); gtk_widget_set_margin_end (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->routes_list), row); update_row_sensitivity (page, page->routes_list); }
/** * create_bookmarks_window: * * Create a new bookmark-editing window. * @list: The CajaBookmarkList that this window will edit. * * Return value: A pointer to the new window. **/ GtkWindow * create_bookmarks_window (CajaBookmarkList *list, CajaWindow *window_source) { GtkWidget *window; GtkTreeViewColumn *col; GtkCellRenderer *rend; GtkBuilder *builder; bookmarks = list; builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UIDIR "/caja-bookmarks-window.ui", NULL)) { return NULL; } window = (GtkWidget *)gtk_builder_get_object (builder, "bookmarks_dialog"); bookmark_list_widget = (GtkTreeView *)gtk_builder_get_object (builder, "bookmark_tree_view"); remove_button = (GtkWidget *)gtk_builder_get_object (builder, "bookmark_delete_button"); jump_button = (GtkWidget *)gtk_builder_get_object (builder, "bookmark_jump_button"); application = window_source->application; if (CAJA_IS_NAVIGATION_WINDOW (window_source)) { parent_is_browser_window = TRUE; } else { parent_is_browser_window = FALSE; } set_up_close_accelerator (window); gtk_window_set_wmclass (GTK_WINDOW (window), "bookmarks", "Caja"); caja_bookmarks_window_restore_geometry (window); g_object_weak_ref (G_OBJECT (window_source), edit_bookmarks_dialog_reset_signals, window_source); bookmark_list_widget = GTK_TREE_VIEW (gtk_builder_get_object (builder, "bookmark_tree_view")); rend = gtk_cell_renderer_pixbuf_new (); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "pixbuf", BOOKMARK_LIST_COLUMN_ICON, NULL); gtk_tree_view_append_column (bookmark_list_widget, GTK_TREE_VIEW_COLUMN (col)); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), CAJA_ICON_SIZE_SMALLER); rend = gtk_cell_renderer_text_new (); g_object_set (rend, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "text", BOOKMARK_LIST_COLUMN_NAME, "style", BOOKMARK_LIST_COLUMN_STYLE, NULL); gtk_tree_view_append_column (bookmark_list_widget, GTK_TREE_VIEW_COLUMN (col)); bookmark_list_store = create_bookmark_store (); setup_empty_list (); gtk_tree_view_set_model (bookmark_list_widget, GTK_TREE_MODEL (bookmark_empty_list_store)); bookmark_selection = GTK_TREE_SELECTION (gtk_tree_view_get_selection (bookmark_list_widget)); name_field = caja_entry_new (); gtk_widget_show (name_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_name_placeholder")), name_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_name_label")), name_field); uri_field = caja_entry_new (); gtk_widget_show (uri_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_location_placeholder")), uri_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_location_label")), uri_field); bookmark_list_changed_signal_id = g_signal_connect (bookmarks, "contents_changed", G_CALLBACK (on_bookmark_list_changed), NULL); row_changed_signal_id = g_signal_connect (bookmark_list_store, "row_changed", G_CALLBACK (on_row_changed), NULL); row_deleted_signal_id = g_signal_connect (bookmark_list_store, "row_deleted", G_CALLBACK (on_row_deleted), NULL); row_activated_signal_id = g_signal_connect (bookmark_list_widget, "row_activated", G_CALLBACK (on_row_activated), window_source); button_pressed_signal_id = g_signal_connect (bookmark_list_widget, "button_press_event", G_CALLBACK (on_button_pressed), NULL); key_pressed_signal_id = g_signal_connect (bookmark_list_widget, "key_press_event", G_CALLBACK (on_key_pressed), NULL); selection_changed_id = g_signal_connect (bookmark_selection, "changed", G_CALLBACK (on_selection_changed), NULL); g_signal_connect (window, "delete_event", G_CALLBACK (on_window_delete_event), NULL); g_signal_connect (window, "hide", G_CALLBACK (on_window_hide_event), NULL); g_signal_connect (window, "destroy", G_CALLBACK (on_window_destroy_event), NULL); g_signal_connect (window, "response", G_CALLBACK (caja_bookmarks_window_response_callback), NULL); name_field_changed_signal_id = g_signal_connect (name_field, "changed", G_CALLBACK (on_name_field_changed), NULL); g_signal_connect (name_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), NULL); g_signal_connect (name_field, "activate", G_CALLBACK (name_or_uri_field_activate), NULL); uri_field_changed_signal_id = g_signal_connect (uri_field, "changed", G_CALLBACK (on_uri_field_changed), NULL); g_signal_connect (uri_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), NULL); g_signal_connect (uri_field, "activate", G_CALLBACK (name_or_uri_field_activate), NULL); g_signal_connect (remove_button, "clicked", G_CALLBACK (on_remove_button_clicked), NULL); jump_button_signal_id = g_signal_connect (jump_button, "clicked", G_CALLBACK (on_jump_button_clicked), window_source); gtk_tree_selection_set_mode (bookmark_selection, GTK_SELECTION_BROWSE); /* Fill in list widget with bookmarks, must be after signals are wired up. */ repopulate(); g_object_unref (builder); return GTK_WINDOW (window); }
static void add_address_row (CEPageIP4 *page, const gchar *address, const gchar *network, const gchar *gateway) { GtkWidget *row; GtkWidget *row_grid; GtkWidget *widget; GtkWidget *label; GtkWidget *delete_button; GtkWidget *image; row = gtk_list_box_row_new (); row_grid = gtk_grid_new (); label = gtk_label_new (_("Address")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 1, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "address", widget); gtk_entry_set_text (GTK_ENTRY (widget), address); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 1, 1, 1); label = gtk_label_new (_("Netmask")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 2, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "network", widget); gtk_entry_set_text (GTK_ENTRY (widget), network); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 2, 1, 1); label = gtk_label_new (_("Gateway")); gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5); gtk_grid_attach (GTK_GRID (row_grid), label, 1, 3, 1, 1); widget = gtk_entry_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget); g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page); g_object_set_data (G_OBJECT (row), "gateway", widget); gtk_entry_set_text (GTK_ENTRY (widget), gateway); gtk_widget_set_margin_start (widget, 10); gtk_widget_set_margin_end (widget, 10); gtk_widget_set_hexpand (widget, TRUE); gtk_grid_attach (GTK_GRID (row_grid), widget, 2, 3, 1, 1); delete_button = gtk_button_new (); gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button"); g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page); image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete Address")); gtk_button_set_image (GTK_BUTTON (delete_button), image); gtk_grid_attach (GTK_GRID (row_grid), delete_button, 3, 2, 1, 1); g_object_set_data (G_OBJECT (row), "delete-button", delete_button); gtk_grid_set_row_spacing (GTK_GRID (row_grid), 10); gtk_widget_set_margin_start (row_grid, 10); gtk_widget_set_margin_end (row_grid, 10); gtk_widget_set_margin_top (row_grid, 10); gtk_widget_set_margin_bottom (row_grid, 10); gtk_widget_set_halign (row_grid, GTK_ALIGN_FILL); gtk_container_add (GTK_CONTAINER (row), row_grid); gtk_widget_show_all (row); gtk_container_add (GTK_CONTAINER (page->address_list), row); update_row_sensitivity (page, page->address_list); }
void procdialog_create_preferences_dialog (ProcData *procdata) { static GtkWidget *dialog = NULL; typedef SpinButtonUpdater SBU; static SBU interval_updater("update-interval"); static SBU graph_interval_updater("graph-update-interval"); static SBU disks_interval_updater("disks-interval"); GtkWidget *notebook; GtkWidget *proc_box; GtkWidget *sys_box; GtkWidget *main_vbox; GtkWidget *vbox, *vbox2, *vbox3; GtkWidget *hbox, *hbox2, *hbox3; GtkWidget *label; GtkAdjustment *adjustment; GtkWidget *spin_button; GtkWidget *check_button; GtkWidget *tab_label; GtkWidget *smooth_button; GtkSizeGroup *size; gfloat update; gchar *tmp; if (prefs_dialog) return; size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); dialog = gtk_dialog_new_with_buttons (_("System Monitor Preferences"), GTK_WINDOW (procdata->app), GTK_DIALOG_DESTROY_WITH_PARENT, "gtk-help", GTK_RESPONSE_HELP, "gtk-close", GTK_RESPONSE_CLOSE, NULL); /* FIXME: we should not declare the window size, but let it's */ /* driven by window childs. The problem is that the fields list */ /* have to show at least 4 items to respect HIG. I don't know */ /* any function to set list height by contents/items inside it. */ gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 500); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); prefs_dialog = dialog; main_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_box_set_spacing (GTK_BOX (main_vbox), 2); notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (notebook), 5); gtk_box_pack_start (GTK_BOX (main_vbox), notebook, TRUE, TRUE, 0); proc_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); gtk_container_set_border_width (GTK_CONTAINER (proc_box), 12); tab_label = gtk_label_new (_("Processes")); gtk_widget_show (tab_label); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), proc_box, tab_label); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (proc_box), vbox, FALSE, FALSE, 0); tmp = g_strdup_printf ("<b>%s</b>", _("Behavior")); label = gtk_label_new (NULL); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0); update = (gfloat) procdata->config.update_interval; adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, MIN_UPDATE_INTERVAL / 1000, MAX_UPDATE_INTERVAL / 1000, 0.25, 1.0, 0); spin_button = gtk_spin_button_new (adjustment, 1.0, 2); gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (spin_button), "focus_out_event", G_CALLBACK (SBU::callback), &interval_updater); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button); hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0); smooth_button = gtk_check_button_new_with_mnemonic(_("Enable _smooth refresh")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(smooth_button), g_settings_get_boolean(procdata->settings, SmoothRefresh::KEY.c_str())); g_signal_connect(G_OBJECT(smooth_button), "toggled", G_CALLBACK(smooth_refresh_toggled), procdata); gtk_box_pack_start(GTK_BOX(hbox2), smooth_button, TRUE, TRUE, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); check_button = gtk_check_button_new_with_mnemonic (_("Alert before ending or _killing processes")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), procdata->config.show_kill_warning); g_signal_connect (G_OBJECT (check_button), "toggled", G_CALLBACK (show_kill_dialog_toggled), procdata); gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0); hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0); GtkWidget *solaris_button = gtk_check_button_new_with_mnemonic(_("Divide CPU usage by CPU count")); gtk_widget_set_tooltip_text(solaris_button, _("Solaris mode")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(solaris_button), g_settings_get_boolean(procdata->settings, procman::settings::solaris_mode.c_str())); g_signal_connect(G_OBJECT(solaris_button), "toggled", G_CALLBACK(solaris_mode_toggled), procdata); gtk_box_pack_start(GTK_BOX(hbox2), solaris_button, TRUE, TRUE, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (proc_box), vbox, TRUE, TRUE, 0); tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields")); label = gtk_label_new (NULL); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); vbox2 = create_field_page (procdata->tree, "proctree", _("Process i_nformation shown in list:")); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); sys_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (sys_box), 12); tab_label = gtk_label_new (_("Resources")); gtk_widget_show (tab_label); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (sys_box), vbox, FALSE, FALSE, 0); tmp = g_strdup_printf ("<b>%s</b>", _("Graphs")); label = gtk_label_new (NULL); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Update interval in 1/10 sec:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); gtk_size_group_add_widget (size, label); hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0); update = (gfloat) procdata->config.graph_update_interval; adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 0.25, 100.0, 0.25, 1.0, 0); spin_button = gtk_spin_button_new (adjustment, 1.0, 2); g_signal_connect (G_OBJECT (spin_button), "focus_out_event", G_CALLBACK(SBU::callback), &graph_interval_updater); gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button); GtkWidget *bits_button; bits_button = gtk_check_button_new_with_mnemonic(_("Show network speed in bits")); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bits_button), g_settings_get_boolean(procdata->settings, procman::settings::network_in_bits.c_str())); g_signal_connect(G_OBJECT(bits_button), "toggled", G_CALLBACK(network_in_bits_toggled), procdata); gtk_box_pack_start(GTK_BOX(vbox2), bits_button, TRUE, TRUE, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0); /* * Devices */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 12); tab_label = gtk_label_new (_("File Systems")); gtk_widget_show (tab_label); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, tab_label); tmp = g_strdup_printf ("<b>%s</b>", _("File Systems")); label = gtk_label_new (NULL); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:")); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0); hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0); update = (gfloat) procdata->config.disks_update_interval; adjustment = (GtkAdjustment *) gtk_adjustment_new (update / 1000.0, 1.0, 100.0, 1.0, 1.0, 0); spin_button = gtk_spin_button_new (adjustment, 1.0, 0); gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button); g_signal_connect (G_OBJECT (spin_button), "focus_out_event", G_CALLBACK(SBU::callback), &disks_interval_updater); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0); check_button = gtk_check_button_new_with_mnemonic (_("Show _all file systems")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button), procdata->config.show_all_fs); g_signal_connect (G_OBJECT (check_button), "toggled", G_CALLBACK (show_all_fs_toggled), procdata); gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0); tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields")); label = gtk_label_new (NULL); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_label_set_markup (GTK_LABEL (label), tmp); g_free (tmp); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); vbox3 = create_field_page (procdata->disk_list, "disktreenew", _("File system i_nformation shown in list:")); gtk_box_pack_start (GTK_BOX (hbox), vbox3, TRUE, TRUE, 0); gtk_widget_show_all (dialog); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (prefs_dialog_button_pressed), procdata); switch (procdata->config.current_tab) { case PROCMAN_TAB_SYSINFO: case PROCMAN_TAB_PROCESSES: gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0); break; case PROCMAN_TAB_RESOURCES: gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 1); break; case PROCMAN_TAB_DISKS: gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 2); break; } }
static GtkWidget * create_field_page(GtkWidget *tree, const gchar *child_schema, const gchar *text) { GtkWidget *vbox; GtkWidget *scrolled; GtkWidget *label; GtkWidget *treeview; GList *it, *columns; GtkListStore *model; GtkTreeViewColumn *column; GtkCellRenderer *cell; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); label = gtk_label_new_with_mnemonic (text); gtk_label_set_xalign (GTK_LABEL (label), 0.0); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), scrolled, TRUE, TRUE, 0); model = gtk_list_store_new (3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER); treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_container_add (GTK_CONTAINER (scrolled), treeview); g_object_unref (G_OBJECT (model)); gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_toggle_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "active", 0, NULL); if (g_strcmp0 (child_schema, "proctree") == 0) g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (proc_field_toggled), model); else if (g_strcmp0 (child_schema, "disktreenew") == 0) g_signal_connect (G_OBJECT (cell), "toggled", G_CALLBACK (disk_field_toggled), model); gtk_tree_view_column_set_clickable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); column = gtk_tree_view_column_new (); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "text", 1, NULL); gtk_tree_view_column_set_title (column, "Not Shown"); gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE); columns = gtk_tree_view_get_columns (GTK_TREE_VIEW (tree)); for(it = columns; it; it = it->next) { GtkTreeViewColumn *column = static_cast<GtkTreeViewColumn*>(it->data); GtkTreeIter iter; const gchar *title; gboolean visible; gint column_id; title = gtk_tree_view_column_get_title (column); if (!title) title = _("Icon"); column_id = gtk_tree_view_column_get_sort_column_id(column); if ((column_id == COL_CGROUP) && (!cgroups_enabled())) continue; if ((column_id == COL_UNIT || column_id == COL_SESSION || column_id == COL_SEAT || column_id == COL_OWNER) #ifdef HAVE_SYSTEMD && !LOGIND_RUNNING() #endif ) continue; visible = gtk_tree_view_column_get_visible (column); gtk_list_store_append (model, &iter); gtk_list_store_set (model, &iter, 0, visible, 1, title, 2, column,-1); } g_list_free(columns); return vbox; }
static void gimp_curves_tool_dialog (GimpImageMapTool *image_map_tool) { GimpCurvesTool *tool = GIMP_CURVES_TOOL (image_map_tool); GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (image_map_tool); GimpCurvesConfig *config = tool->config; GtkListStore *store; GtkSizeGroup *label_group; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *hbox2; GtkWidget *label; GtkWidget *frame; GtkWidget *table; GtkWidget *button; GtkWidget *bar; GtkWidget *combo; g_signal_connect (image_map_tool->settings_box, "file-dialog-setup", G_CALLBACK (gimp_curves_tool_export_setup), image_map_tool); main_vbox = gimp_image_map_tool_dialog_get_vbox (image_map_tool); label_group = gimp_image_map_tool_dialog_get_label_group (image_map_tool); /* The combo box for selecting channels */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Cha_nnel:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); gtk_size_group_add_widget (label_group, label); store = gimp_enum_store_new_with_range (GIMP_TYPE_HISTOGRAM_CHANNEL, GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_ALPHA); tool->channel_menu = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store)); g_object_unref (store); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (tool->channel_menu), config->channel); gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (tool->channel_menu), "gimp-channel"); gtk_box_pack_start (GTK_BOX (hbox), tool->channel_menu, FALSE, FALSE, 0); gtk_widget_show (tool->channel_menu); g_signal_connect (tool->channel_menu, "changed", G_CALLBACK (curves_channel_callback), tool); gtk_label_set_mnemonic_widget (GTK_LABEL (label), tool->channel_menu); button = gtk_button_new_with_mnemonic (_("R_eset Channel")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (curves_channel_reset_callback), tool); /* The histogram scale radio buttons */ hbox2 = gimp_prop_enum_stock_box_new (G_OBJECT (tool_options), "histogram-scale", "gimp-histogram", 0, 0); gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); /* The table for the color bars and the graph */ table = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacings (GTK_TABLE (table), 2); gtk_table_set_row_spacings (GTK_TABLE (table), 2); gtk_box_pack_start (GTK_BOX (main_vbox), table, TRUE, TRUE, 0); /* The left color bar */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_table_attach (GTK_TABLE (table), vbox, 0, 1, 0, 1, GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (vbox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, RADIUS); gtk_widget_show (frame); tool->yrange = gimp_color_bar_new (GTK_ORIENTATION_VERTICAL); gtk_widget_set_size_request (tool->yrange, BAR_SIZE, -1); gtk_container_add (GTK_CONTAINER (frame), tool->yrange); gtk_widget_show (tool->yrange); /* The curves graph */ frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), frame, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_widget_show (frame); tool->graph = gimp_curve_view_new (); gimp_curve_view_set_range_x (GIMP_CURVE_VIEW (tool->graph), 0, 255); gimp_curve_view_set_range_y (GIMP_CURVE_VIEW (tool->graph), 0, 255); gtk_widget_set_size_request (tool->graph, GRAPH_SIZE + RADIUS * 2, GRAPH_SIZE + RADIUS * 2); g_object_set (tool->graph, "border-width", RADIUS, "subdivisions", 1, NULL); gimp_curve_view_set_curve (GIMP_CURVE_VIEW (tool->graph), config->curve[config->channel], &channel_colors[config->channel]); gtk_container_add (GTK_CONTAINER (frame), tool->graph); gtk_widget_show (tool->graph); gimp_histogram_options_connect_view (GIMP_HISTOGRAM_OPTIONS (tool_options), GIMP_HISTOGRAM_VIEW (tool->graph)); /* The bottom color bar */ hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_table_attach (GTK_TABLE (table), hbox2, 1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0); gtk_widget_show (hbox2); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (hbox2), frame, TRUE, TRUE, RADIUS); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); tool->xrange = gimp_color_bar_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_size_request (tool->xrange, -1, BAR_SIZE / 2); gtk_box_pack_start (GTK_BOX (vbox), tool->xrange, TRUE, TRUE, 0); gtk_widget_show (tool->xrange); bar = gimp_color_bar_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), bar, TRUE, TRUE, 0); gtk_widget_show (bar); gtk_widget_show (table); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_end (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Curve _type:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); tool->curve_type = combo = gimp_enum_combo_box_new (GIMP_TYPE_CURVE_TYPE); gimp_enum_combo_box_set_stock_prefix (GIMP_ENUM_COMBO_BOX (combo), "gimp-curve"); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), 0, G_CALLBACK (curves_curve_type_callback), tool); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); }
int main (int argc, char **argv) { GdkScreen *screen; GtkWidget *nb; GtkWidget *general_vbox; GtkWidget *behaviour_vbox; GtkWidget *placement_vbox; GtkWidget *widget; GtkWidget *vbox; GtkWidget *vbox1; GtkWidget *hbox; GtkWidget *hbox1; GtkWidget *hbox2; GtkWidget *hbox3; GtkWidget *content_area; gchar *str; const char *current_wm; int i; bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gtk_init (&argc, &argv); screen = gdk_display_get_default_screen (gdk_display_get_default ()); current_wm = gdk_x11_screen_get_window_manager_name (screen); if (g_strcmp0 (current_wm, WM_COMMON_METACITY) == 0) { mate_metacity_config_tool (); return 0; } if (g_strcmp0 (current_wm, WM_COMMON_MARCO) != 0) { wm_unsupported (); return 1; } marco_settings = g_settings_new (MARCO_SCHEMA); /* Window */ dialog_win = gtk_dialog_new_with_buttons (_("Window Preferences"), NULL, GTK_DIALOG_MODAL, GTK_STOCK_HELP, GTK_RESPONSE_HELP, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); //gtk_window_set_resizable (GTK_WINDOW (dialog_win), FALSE); gtk_window_set_icon_name (GTK_WINDOW (dialog_win), "preferences-system-windows"); gtk_container_set_border_width (GTK_CONTAINER (dialog_win), 10); nb = gtk_notebook_new (); general_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); behaviour_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); placement_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); widget = gtk_label_new (_("General")); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), general_vbox, FALSE, FALSE, 6); gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget); widget = gtk_label_new (_("Behaviour")); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), behaviour_vbox, FALSE, FALSE, 6); gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget); widget = gtk_label_new (_("Placement")); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), placement_vbox, FALSE, FALSE, 6); gtk_notebook_append_page (GTK_NOTEBOOK (nb), hbox, widget); /* Compositing manager */ widget = title_label_new (N_("Compositing Manager")); gtk_box_pack_start (GTK_BOX (general_vbox), widget, FALSE, FALSE, 6); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); compositing_checkbutton = gtk_check_button_new_with_mnemonic (_("Enable software _compositing window manager")); compositing_fast_alt_tab_checkbutton = gtk_check_button_new_with_mnemonic (_("Disable _thumbnails in Alt-Tab")); gtk_box_pack_start (GTK_BOX (vbox), compositing_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox1), compositing_fast_alt_tab_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox1, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (general_vbox), hbox, FALSE, FALSE, 6); /* Titlebar buttons */ widget = title_label_new (N_("Titlebar Buttons")); gtk_box_pack_start (GTK_BOX (general_vbox), widget, FALSE, FALSE, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); widget = gtk_label_new (_("Position:")); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6); titlebar_layout_optionmenu = gtk_combo_box_text_new (); gtk_box_pack_start (GTK_BOX (hbox), titlebar_layout_optionmenu, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (general_vbox), hbox, FALSE, FALSE, 6); /* New Windows */ widget = title_label_new (N_("New Windows")); gtk_box_pack_start (GTK_BOX (placement_vbox), widget, FALSE, FALSE, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); center_new_windows_checkbutton = gtk_check_button_new_with_mnemonic (_("Center _new windows")); gtk_box_pack_start (GTK_BOX (hbox), center_new_windows_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (placement_vbox), hbox, FALSE, FALSE, 6); /* Window Snapping */ widget = title_label_new (N_("Window Snapping")); gtk_box_pack_start (GTK_BOX (placement_vbox), widget, FALSE, FALSE, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); side_by_side_tiling_checkbutton = gtk_check_button_new_with_mnemonic (_("Enable side by side _tiling")); gtk_box_pack_start (GTK_BOX (hbox), side_by_side_tiling_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (placement_vbox), hbox, FALSE, FALSE, 6); /* Window Selection */ widget = title_label_new (N_("Window Selection")); gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); focus_mode_checkbutton = gtk_check_button_new_with_mnemonic (_("_Select windows when the mouse moves over them")); gtk_box_pack_start (GTK_BOX (vbox), focus_mode_checkbutton, FALSE, FALSE, 6); focus_mode_mouse_checkbutton = gtk_check_button_new_with_mnemonic (_("U_nselect windows when the mouse leaves them")); gtk_box_pack_start (GTK_BOX (hbox1), focus_mode_mouse_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, FALSE, FALSE, 6); autoraise_checkbutton = gtk_check_button_new_with_mnemonic (_("_Raise selected windows after an interval")); gtk_box_pack_start (GTK_BOX (hbox2), autoraise_checkbutton, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 6); autoraise_delay_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); autoraise_delay_slider = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 10, 0.2); widget = gtk_label_new_with_mnemonic (_("_Interval before raising:")); gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), widget, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), autoraise_delay_slider, TRUE, TRUE, 6); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), autoraise_delay_slider); widget = gtk_label_new (_("seconds")); gtk_range_set_increments (GTK_RANGE (autoraise_delay_slider), 0.2, 1.0); gtk_box_pack_start (GTK_BOX (autoraise_delay_hbox), widget, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox1), autoraise_delay_hbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox3), vbox1, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox3, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6); /* Titlebar Action */ widget = title_label_new (N_("Titlebar Action")); gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); widget = gtk_label_new_with_mnemonic (_("_Double-click titlebar to perform this action:")); gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6); double_click_titlebar_optionmenu = gtk_combo_box_text_new (); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), double_click_titlebar_optionmenu); gtk_box_pack_start (GTK_BOX (hbox), double_click_titlebar_optionmenu, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6); /* Movement Key */ widget = title_label_new (N_("Movement Key")); gtk_box_pack_start (GTK_BOX (behaviour_vbox), widget, FALSE, FALSE, 6); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); widget = gtk_label_new_with_mnemonic (_("To move a window, press-and-hold this key then grab the window:")); #if GTK_CHECK_VERSION (3, 16, 0) gtk_label_set_xalign (GTK_LABEL (widget), 0.0); gtk_label_set_yalign (GTK_LABEL (widget), 0.0); #else gtk_misc_set_alignment (GTK_MISC (widget), 0.0, 0.0); #endif gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 6); alt_click_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), alt_click_vbox); gtk_box_pack_start (GTK_BOX (vbox), alt_click_vbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 6); gtk_box_pack_start (GTK_BOX (behaviour_vbox), hbox, FALSE, FALSE, 6); reload_mouse_modifiers (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (titlebar_layout_optionmenu), _("Right")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (titlebar_layout_optionmenu), _("Left")); str = g_settings_get_string (marco_settings, MARCO_BUTTON_LAYOUT_KEY); gtk_combo_box_set_active (GTK_COMBO_BOX (titlebar_layout_optionmenu), g_strcmp0 (str, MARCO_BUTTON_LAYOUT_RIGHT) == 0 ? 0 : 1); g_free (str); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Roll up")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize Horizontally")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Maximize Vertically")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("Minimize")); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (double_click_titlebar_optionmenu), _("None")); gtk_combo_box_set_active (GTK_COMBO_BOX (double_click_titlebar_optionmenu), g_settings_get_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY)); set_alt_click_value (); gtk_range_set_value (GTK_RANGE (autoraise_delay_slider), g_settings_get_int (marco_settings, MARCO_AUTORAISE_DELAY_KEY) / 1000.0); gtk_combo_box_set_active (GTK_COMBO_BOX (double_click_titlebar_optionmenu), g_settings_get_enum (marco_settings, MARCO_DOUBLE_CLICK_TITLEBAR_KEY)); g_signal_connect (G_OBJECT (dialog_win), "response", G_CALLBACK (response_cb), NULL); g_signal_connect (G_OBJECT (dialog_win), "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (marco_settings, "changed", G_CALLBACK (marco_settings_changed_callback), NULL); g_settings_bind (marco_settings, MARCO_COMPOSITING_MANAGER_KEY, compositing_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (marco_settings, MARCO_COMPOSITING_FAST_ALT_TAB_KEY, compositing_fast_alt_tab_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (marco_settings, MARCO_SIDE_BY_SIDE_TILING_KEY, side_by_side_tiling_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (marco_settings, MARCO_CENTER_NEW_WINDOWS_KEY, center_new_windows_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (marco_settings, "changed::" MARCO_FOCUS_KEY, G_CALLBACK (mouse_focus_changed_callback), NULL); /* Initialize the checkbox state appropriately */ mouse_focus_changed_callback(marco_settings, MARCO_FOCUS_KEY, NULL); g_signal_connect (focus_mode_checkbutton, "toggled", G_CALLBACK (mouse_focus_toggled_callback), NULL); g_signal_connect (focus_mode_mouse_checkbutton, "toggled", G_CALLBACK (mouse_focus_toggled_callback), NULL); g_settings_bind (marco_settings, MARCO_AUTORAISE_KEY, autoraise_checkbutton, "active", G_SETTINGS_BIND_DEFAULT); g_signal_connect (autoraise_delay_slider, "value_changed", G_CALLBACK (autoraise_delay_value_changed_callback), NULL); g_signal_connect (double_click_titlebar_optionmenu, "changed", G_CALLBACK (double_click_titlebar_changed_callback), NULL); g_signal_connect (titlebar_layout_optionmenu, "changed", G_CALLBACK (titlebar_layout_changed_callback), NULL); g_signal_connect (G_OBJECT (screen), "window_manager_changed", G_CALLBACK (wm_changed_callback), NULL); i = 0; while (i < n_mouse_modifiers) { g_signal_connect (G_OBJECT (mouse_modifiers[i].radio), "toggled", G_CALLBACK (alt_click_radio_toggled_callback), &mouse_modifiers[i]); ++i; } /* update sensitivity */ update_sensitivity (); capplet_set_icon (dialog_win, "preferences-system-windows"); content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog_win)); gtk_box_pack_start (GTK_BOX (content_area), nb, TRUE, TRUE, 0); gtk_widget_show_all (dialog_win); gtk_main (); g_object_unref (marco_settings); return 0; }
static void mdm_lang_setup_treeview (void) { if (dialog == NULL) { GtkWidget *main_vbox; GtkWidget *button; GtkWidget **tmp_p; GtkWidget *swindow; GtkWidget *label; char *s; dialog = gtk_dialog_new_with_buttons (_("Select a Language"), #ifdef TODO GTK_WINDOW (parent_window), #endif NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_button_new_with_mnemonic (_("Change _Language")); GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_show (button); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_OK); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), 2); main_vbox = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 5); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), main_vbox, TRUE, TRUE, 0); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); /* evil gcc warnings */ tmp_p = &dialog; g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer *)tmp_p); s = g_strdup (_("_Select the language for your session to use:")); label = gtk_label_new_with_mnemonic (s); gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5); g_free (s); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); tv = gtk_tree_view_new (); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tv), TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), tv); /* FIXME: we should handle this better, but things really look * bad if we aren't always LTR */ gtk_widget_set_direction (tv, GTK_TEXT_DIR_LTR); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tv), FALSE); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv), GTK_DIALOG_MODAL, NULL, gtk_cell_renderer_text_new (), "text", TRANSLATED_NAME_COLUMN, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tv), GTK_DIALOG_MODAL, NULL, gtk_cell_renderer_text_new (), "markup", UNTRANSLATED_NAME_COLUMN, NULL); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (swindow), tv); gtk_box_pack_start (GTK_BOX (main_vbox), swindow, TRUE, TRUE, 0); gtk_window_set_default_size (GTK_WINDOW (dialog), MIN (400, mdm_wm_screen.width), MIN (600, mdm_wm_screen.height)); g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (tv))), "changed", (GCallback) selection_changed, NULL); g_signal_connect (G_OBJECT (tv), "row_activated", (GCallback) tree_row_activated, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (tv), GTK_TREE_MODEL (lang_model)); } }
static gboolean decompose_dialog (void) { GtkWidget *dialog; GtkWidget *main_vbox; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkWidget *combo; GtkWidget *toggle; gint j; gint extract_idx; gboolean run; extract_idx = 0; for (j = 0; j < G_N_ELEMENTS (extract); j++) { if (extract[j].dialog && g_ascii_strcasecmp (decovals.extract_type, extract[j].type) == 0) { extract_idx = j; break; } } gimp_ui_init (PLUG_IN_BINARY, FALSE); dialog = gimp_dialog_new (_("Decompose"), 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); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); 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); frame = gimp_frame_new (_("Extract Channels")); gtk_box_pack_start (GTK_BOX (main_vbox), frame, TRUE, TRUE, 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); label = gtk_label_new_with_mnemonic (_("Color _model:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = g_object_new (GIMP_TYPE_INT_COMBO_BOX, NULL); for (j = 0; j < G_N_ELEMENTS (extract); j++) { if (extract[j].dialog) { gchar *label = g_strdup (gettext (extract[j].type)); gchar *l; for (l = label; *l; l++) if (*l == '-' || *l == '_') *l = ' '; gimp_int_combo_box_append (GIMP_INT_COMBO_BOX (combo), GIMP_INT_STORE_LABEL, label, GIMP_INT_STORE_VALUE, j, -1); g_free (label); } } gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), extract_idx, G_CALLBACK (gimp_int_combo_box_get_active), &extract_idx); toggle = gtk_check_button_new_with_mnemonic (_("_Decompose to layers")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), decovals.as_layers); 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), &decovals.as_layers); toggle = gtk_check_button_new_with_mnemonic (_("_Foreground as registration color")); gimp_help_set_help_data (toggle, _("Pixels in the foreground color will " "appear black in all output images. " "This can be used for things like crop " "marks that have to show up on all " "channels."), PLUG_IN_PROC); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), decovals.use_registration); 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), &decovals.use_registration); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); gtk_widget_destroy (dialog); if (run) strncpy (decovals.extract_type, extract[extract_idx].type, sizeof decovals.extract_type - 1); return run; }
GtkWidget * convert_dialog_new (GimpImage *image, GimpContext *context, GtkWidget *parent, GimpProgress *progress) { IndexedDialog *dialog; GtkWidget *button; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *label; GtkObject *adjustment; GtkWidget *spinbutton; GtkWidget *frame; GtkWidget *toggle; GtkWidget *palette_box; GtkWidget *combo; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); dialog = g_slice_new0 (IndexedDialog); dialog->image = image; dialog->progress = progress; dialog->dither_type = saved_dither_type; dialog->alpha_dither = saved_alpha_dither; dialog->remove_dups = saved_remove_dups; dialog->num_colors = saved_num_colors; dialog->palette_type = saved_palette_type; dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("Indexed Color Conversion"), "gimp-image-convert-indexed", GIMP_STOCK_CONVERT_INDEXED, _("Convert Image to Indexed Colors"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_CONVERT_INDEXED, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); button = gtk_dialog_add_button (GTK_DIALOG (dialog->dialog), _("C_onvert"), GTK_RESPONSE_OK); gtk_button_set_image (GTK_BUTTON (button), gtk_image_new_from_stock (GIMP_STOCK_CONVERT_INDEXED, GTK_ICON_SIZE_BUTTON)); gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), FALSE); g_object_weak_ref (G_OBJECT (dialog->dialog), (GWeakNotify) convert_dialog_free, dialog); g_signal_connect (dialog->dialog, "response", G_CALLBACK (convert_dialog_response), dialog); palette_box = convert_dialog_palette_box (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->dialog)->vbox), main_vbox); gtk_widget_show (main_vbox); /* palette */ frame = gimp_enum_radio_frame_new_with_range (GIMP_TYPE_CONVERT_PALETTE_TYPE, GIMP_MAKE_PALETTE, (palette_box ? GIMP_CUSTOM_PALETTE : GIMP_MONO_PALETTE), gtk_label_new (_("Colormap")), G_CALLBACK (gimp_radio_button_update), &dialog->palette_type, &button); gimp_int_radio_group_set_active (GTK_RADIO_BUTTON (button), dialog->palette_type); gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); /* max n_colors */ hbox = gtk_hbox_new (FALSE, 6); gimp_enum_radio_frame_add (GTK_FRAME (frame), hbox, GIMP_MAKE_PALETTE); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("_Maximum number of colors:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); if (dialog->num_colors == 256 && gimp_image_has_alpha (image)) dialog->num_colors = 255; spinbutton = gimp_spin_button_new (&adjustment, dialog->num_colors, 2, 256, 1, 8, 0, 1, 0); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); g_signal_connect (adjustment, "value-changed", G_CALLBACK (gimp_int_adjustment_update), &dialog->num_colors); /* custom palette */ if (palette_box) { gimp_enum_radio_frame_add (GTK_FRAME (frame), palette_box, GIMP_CUSTOM_PALETTE); gtk_widget_show (palette_box); } vbox = gtk_bin_get_child (GTK_BIN (frame)); toggle = gtk_check_button_new_with_mnemonic (_("_Remove unused colors " "from colormap")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->remove_dups); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 3); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->remove_dups); g_object_set_data (G_OBJECT (button), "inverse_sensitive", toggle); gimp_toggle_button_sensitive_update (GTK_TOGGLE_BUTTON (button)); /* dithering */ frame = gimp_frame_new (_("Dithering")); 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); label = gtk_label_new_with_mnemonic (_("Color _dithering:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_enum_combo_box_new (GIMP_TYPE_CONVERT_DITHER_TYPE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), dialog->dither_type, G_CALLBACK (gimp_int_combo_box_get_active), &dialog->dither_type); toggle = gtk_check_button_new_with_mnemonic (_("Enable dithering of _transparency")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->alpha_dither); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->alpha_dither); return dialog->dialog; }
/** * show_properties_dialog * * Description: * displays the properties dialog **/ void show_properties_dialog (void) { GtkWidget *notebook; GtkWidget *cpage; GtkWidget *gpage; GtkWidget *kpage; GtkWidget *label; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *typemenu; GtkWidget *pmapmenu; GtkWidget *chkbox; GtkWidget *safe_chkbox; GtkWidget *grid; GtkWidget *dbut; GtkWidget *w; GtkWidget *controls_list; if (propbox) return; propbox = gtk_dialog_new_with_buttons (_("Preferences"), GTK_WINDOW (window), GTK_DIALOG_USE_HEADER_BAR, NULL); gtk_container_set_border_width (GTK_CONTAINER (propbox), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (propbox))), 2); /* Set up notebook and add it to hbox of the gtk_dialog */ g_signal_connect (G_OBJECT (propbox), "destroy", G_CALLBACK (gtk_widget_destroyed), &propbox); notebook = gtk_notebook_new (); gtk_container_set_border_width (GTK_CONTAINER (notebook), 5); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (propbox))), notebook, TRUE, TRUE, 0); /* The configuration page */ cpage = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); gtk_container_set_border_width (GTK_CONTAINER (cpage), 12); grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 12); gtk_box_pack_start (GTK_BOX (cpage), grid, FALSE, FALSE, 0); label = gtk_label_new (_("Game Type")); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1); typemenu = gtk_combo_box_text_new (); fill_typemenu (typemenu); gtk_grid_attach (GTK_GRID (grid), typemenu, 1, 0, 1, 1); g_signal_connect (G_OBJECT (typemenu), "changed", G_CALLBACK (type_selection), NULL); chkbox = gtk_check_button_new_with_mnemonic (_("_Use safe moves")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkbox), properties.safe_moves); gtk_grid_attach (GTK_GRID (grid), chkbox, 0, 1, 2, 1); gtk_widget_set_tooltip_text (chkbox, _("Prevent accidental moves that result in getting killed.")); safe_chkbox = chkbox; chkbox = gtk_check_button_new_with_mnemonic (_("U_se super safe moves")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkbox), properties.super_safe_moves); g_signal_connect (G_OBJECT (chkbox), "clicked", (GCallback) super_safe_cb, NULL); gtk_grid_attach (GTK_GRID (grid), chkbox, 0, 2, 2, 1); gtk_widget_set_tooltip_text (chkbox, _("Prevents all moves that result in getting killed.")); gtk_widget_set_sensitive (chkbox, properties.safe_moves); g_signal_connect (G_OBJECT (safe_chkbox), "clicked", (GCallback) safe_cb, (gpointer) chkbox); chkbox = gtk_check_button_new_with_mnemonic (_("_Enable sounds")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkbox), properties.sound); g_signal_connect (G_OBJECT (chkbox), "clicked", (GCallback) sound_cb, NULL); gtk_grid_attach (GTK_GRID (grid), chkbox, 0, 3, 2, 1); gtk_widget_set_tooltip_text (chkbox, _("Play sounds for events like winning a level and dying.")); label = gtk_label_new_with_mnemonic (_("Game")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), cpage, label); /* The graphics page */ gpage = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); gtk_container_set_border_width (GTK_CONTAINER (gpage), 12); grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 12); gtk_box_pack_start (GTK_BOX (gpage), grid, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("_Image theme:")); gtk_widget_set_hexpand (label, TRUE); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1); pmapmenu = make_theme_menu (); g_signal_connect (G_OBJECT (pmapmenu), "changed", G_CALLBACK (pmap_selection), NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), pmapmenu); gtk_grid_attach (GTK_GRID (grid), pmapmenu, 1, 0, 1, 1); label = gtk_label_new_with_mnemonic (_("_Background color:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); w = gtk_color_button_new (); gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (w), &properties.bgcolour); g_signal_connect (G_OBJECT (w), "color_set", G_CALLBACK (bg_color_callback), NULL); gtk_label_set_mnemonic_widget (GTK_LABEL (label), w); gtk_grid_attach (GTK_GRID (grid), w, 1, 1, 1, 1); label = gtk_label_new_with_mnemonic (_("Appearance")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), gpage, label); /* The keyboard page */ kpage = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); gtk_container_set_border_width (GTK_CONTAINER (kpage), 12); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (kpage), vbox, TRUE, TRUE, 0); controls_list = games_controls_list_new (settings); games_controls_list_add_controls (GAMES_CONTROLS_LIST (controls_list), "key00", _("Key to move NW"), g_settings_get_default_value (settings, "key00"), "key01", _("Key to move N"), g_settings_get_default_value (settings, "key01"), "key02", _("Key to move NE"), g_settings_get_default_value (settings, "key02"), "key03", _("Key to move W"), g_settings_get_default_value (settings, "key03"), "key04", _("Key to hold"), g_settings_get_default_value (settings, "key04"), "key05", _("Key to move E"), g_settings_get_default_value (settings, "key05"), "key06", _("Key to move SW"), g_settings_get_default_value (settings, "key06"), "key07", _("Key to move S"), g_settings_get_default_value (settings, "key07"), "key08", _("Key to move SE"), g_settings_get_default_value (settings, "key08"), NULL); gtk_box_pack_start (GTK_BOX (vbox), controls_list, TRUE, TRUE, 0); hbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_START); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); dbut = gtk_button_new_with_mnemonic (_("_Restore Defaults")); g_signal_connect (G_OBJECT (dbut), "clicked", G_CALLBACK (defkey_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), dbut, FALSE, FALSE, 0); label = gtk_label_new_with_mnemonic (_("Keyboard")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), kpage, label); g_signal_connect (G_OBJECT (propbox), "delete_event", G_CALLBACK (delete_cb), NULL); g_signal_connect (G_OBJECT (propbox), "response", G_CALLBACK (apply_cb), NULL); gtk_widget_show_all (propbox); }
static GncTaxTable * new_tax_table_dialog (TaxTableWindow *ttw, gboolean new_table, GncTaxTableEntry *entry, const char *name) { GncTaxTable *created_table = NULL; NewTaxTable *ntt; GtkBuilder *builder; GtkWidget *box, *widget, *combo; gboolean done; gint response, index; if (!ttw) return NULL; if (new_table && entry) return NULL; ntt = g_new0 (NewTaxTable, 1); ntt->ttw = ttw; ntt->entry = entry; ntt->new_table = new_table; if (entry) ntt->type = gncTaxTableEntryGetType (entry); else ntt->type = GNC_AMT_TYPE_PERCENT; /* Open and read the Glade File */ builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "dialog-tax-table.glade", "type_liststore"); gnc_builder_add_from_file (builder, "dialog-tax-table.glade", "New Tax Table Dialog"); ntt->dialog = GTK_WIDGET(gtk_builder_get_object (builder, "New Tax Table Dialog")); ntt->name_entry = GTK_WIDGET(gtk_builder_get_object (builder, "name_entry")); if (name) gtk_entry_set_text (GTK_ENTRY (ntt->name_entry), name); /* Create the menu */ combo = GTK_WIDGET(gtk_builder_get_object (builder, "type_combobox")); index = ntt->type ? ntt->type : GNC_AMT_TYPE_VALUE; gtk_combo_box_set_active(GTK_COMBO_BOX(combo), index - 1); g_signal_connect (combo, "changed", G_CALLBACK (combo_changed), ntt); /* Attach our own widgets */ box = GTK_WIDGET(gtk_builder_get_object (builder, "amount_box")); ntt->amount_entry = widget = gnc_amount_edit_new (); gnc_amount_edit_set_evaluate_on_enter (GNC_AMOUNT_EDIT (widget), TRUE); gnc_amount_edit_set_fraction (GNC_AMOUNT_EDIT (widget), 100000); gtk_box_pack_start (GTK_BOX (box), widget, TRUE, TRUE, 0); box = GTK_WIDGET(gtk_builder_get_object (builder, "acct_window")); ntt->acct_tree = GTK_WIDGET(gnc_tree_view_account_new (FALSE)); gtk_container_add (GTK_CONTAINER (box), ntt->acct_tree); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(ntt->acct_tree), FALSE); /* Make 'enter' do the right thing */ gtk_entry_set_activates_default(GTK_ENTRY (gnc_amount_edit_gtk_entry (GNC_AMOUNT_EDIT (ntt->amount_entry))), TRUE); /* Fix mnemonics for generated target widgets */ widget = GTK_WIDGET(gtk_builder_get_object (builder, "value_label")); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), ntt->amount_entry); widget = GTK_WIDGET(gtk_builder_get_object (builder, "account_label")); gtk_label_set_mnemonic_widget (GTK_LABEL (widget), ntt->acct_tree); /* Fill in the widgets appropriately */ if (entry) { gnc_amount_edit_set_amount (GNC_AMOUNT_EDIT (ntt->amount_entry), gncTaxTableEntryGetAmount (entry)); gnc_tree_view_account_set_selected_account (GNC_TREE_VIEW_ACCOUNT (ntt->acct_tree), gncTaxTableEntryGetAccount (entry)); } /* Set our parent */ gtk_window_set_transient_for (GTK_WINDOW(ntt->dialog), GTK_WINDOW(ttw->dialog)); /* Setup signals */ gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, ntt); /* Show what we should */ gtk_widget_show_all (ntt->dialog); if (new_table == FALSE) { gtk_widget_hide (GTK_WIDGET(gtk_builder_get_object (builder, "table_title"))); gtk_widget_hide (GTK_WIDGET(gtk_builder_get_object (builder, "table_name"))); gtk_widget_hide (GTK_WIDGET(gtk_builder_get_object (builder, "spacer"))); gtk_widget_hide (ntt->name_entry); /* Tables are great for layout, but a pain when you hide widgets */ widget = GTK_WIDGET(gtk_builder_get_object (builder, "ttd_table")); gtk_table_set_row_spacing (GTK_TABLE(widget), 0, 0); gtk_table_set_row_spacing (GTK_TABLE(widget), 1, 0); gtk_table_set_row_spacing (GTK_TABLE(widget), 2, 0); gtk_widget_grab_focus (gnc_amount_edit_gtk_entry (GNC_AMOUNT_EDIT (ntt->amount_entry))); } else gtk_widget_grab_focus (ntt->name_entry); /* Display the dialog now that we're done manipulating it */ gtk_widget_show (ntt->dialog); done = FALSE; while (!done) { response = gtk_dialog_run (GTK_DIALOG (ntt->dialog)); switch (response) { case GTK_RESPONSE_OK: if (new_tax_table_ok_cb (ntt)) { created_table = ntt->created_table; done = TRUE; } break; default: done = TRUE; break; } } g_object_unref(G_OBJECT(builder)); gtk_widget_destroy(ntt->dialog); g_free(ntt); return created_table; }
ShowNotesDialog::ShowNotesDialog(int dummy) { event_id = 0; extern Settings *settings; gtkbuilder = gtk_builder_new (); gtk_builder_add_from_file (gtkbuilder, gw_build_filename (Directories->get_package_data(), "gtkbuilder.showprojectnotesdialog.xml").c_str(), NULL); dialog = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "dialog")); GSList *verse_reference_group = NULL; radiobutton_current_verse = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_current_verse")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_current_verse), verse_reference_group); verse_reference_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_current_verse)); g_signal_connect ((gpointer) radiobutton_current_verse, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); radiobutton_current_chapter = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_current_chapter")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_current_chapter), verse_reference_group); verse_reference_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_current_chapter)); g_signal_connect ((gpointer) radiobutton_current_chapter, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); radiobutton_current_book = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_current_book")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_current_book), verse_reference_group); verse_reference_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_current_book)); g_signal_connect ((gpointer) radiobutton_current_book, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); radiobutton_any_verse = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_any_verse")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_any_verse), verse_reference_group); verse_reference_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_any_verse)); g_signal_connect ((gpointer) radiobutton_any_verse, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); GSList *radiobutton_date_group = NULL; radiobutton_today = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_today")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_today), radiobutton_date_group); radiobutton_date_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_today)); g_signal_connect ((gpointer) radiobutton_today, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); radiobutton_between = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_between")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_between), radiobutton_date_group); radiobutton_date_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_between)); g_signal_connect ((gpointer) radiobutton_between, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); button_start = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_start")); g_signal_connect((gpointer) button_start, "clicked", G_CALLBACK(on_fromdatebutton_clicked), gpointer(this)); g_signal_connect ((gpointer) button_start, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); button_end = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_end")); g_signal_connect((gpointer) button_end, "clicked", G_CALLBACK(on_todatebutton_clicked), gpointer(this)); g_signal_connect ((gpointer) button_end, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); radiobutton_at_any_time = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_at_any_time")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_at_any_time), radiobutton_date_group); radiobutton_date_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_at_any_time)); g_signal_connect ((gpointer) radiobutton_at_any_time, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); // Glade-3 does not seem to be able to work with gtk_combo_box_new_text yet. Workaround below. label_category = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_category")); hbox_category = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "hbox_category")); combobox_category = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "combobox_category")); gtk_widget_destroy (combobox_category); combobox_category = gtk_combo_box_new_text(); gtk_widget_show(combobox_category); gtk_box_pack_start(GTK_BOX(hbox_category), combobox_category, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget(GTK_LABEL(label_category), combobox_category); g_signal_connect ((gpointer) combobox_category, "changed", G_CALLBACK (on_combobox_changed), gpointer (this)); GSList *radiobutton_project_group = NULL; radiobutton_current_project = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_current_project")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_current_project), radiobutton_project_group); radiobutton_project_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_current_project)); g_signal_connect ((gpointer) radiobutton_current_project, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); radiobutton_any_project = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_any_project")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_any_project), radiobutton_project_group); radiobutton_project_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_any_project)); g_signal_connect ((gpointer) radiobutton_any_project, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); checkbutton_title = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_title")); g_signal_connect((gpointer) checkbutton_title, "toggled", G_CALLBACK(on_checkbutton_show_title_toggled), gpointer(this)); g_signal_connect ((gpointer) checkbutton_title, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); checkbutton_project = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_project")); g_signal_connect ((gpointer) checkbutton_project, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); checkbutton_category = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_category")); g_signal_connect ((gpointer) checkbutton_category, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); checkbutton_date_created = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_date_created")); g_signal_connect ((gpointer) checkbutton_date_created, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); checkbutton_created_by = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_created_by")); g_signal_connect ((gpointer) checkbutton_created_by, "clicked", G_CALLBACK (on_button_clicked), gpointer (this)); GSList *radiobutton_text_group = NULL; radiobutton_full = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_full")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_full), radiobutton_text_group); radiobutton_text_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_full)); radiobutton_summary = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_summary")); gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_summary), radiobutton_text_group); radiobutton_text_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_summary)); checkbutton_add_ref_text = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "checkbutton_add_ref_text")); // Set the reference selection. GtkToggleButton *refbutton = reference_get_button(settings->genconfig.notes_selection_reference_get()); if (refbutton) { gtk_toggle_button_set_active(refbutton, true); } // Set the edited selection. GtkToggleButton *editbutton = edited_get_button(settings->genconfig.notes_selection_edited_get()); if (editbutton) { gtk_toggle_button_set_active(editbutton, true); } from_day = settings->genconfig.notes_selection_date_from_get(); to_day = settings->genconfig.notes_selection_date_to_get(); // Load available categories and set the combo. ReadText rt(notes_categories_filename()); rt.lines.push_back(all_categories()); combobox_set_strings(combobox_category, rt.lines); ustring category = settings->genconfig.notes_selection_category_get(); if (category.empty()) category = all_categories(); combobox_set_string(combobox_category, category); // Project selection. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_any_project), !settings->genconfig.notes_selection_current_project_get()); // Title and inclusions. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_title), settings->session.project_notes_show_title); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_project), settings->genconfig.notes_display_project_get()); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_category), settings->genconfig.notes_display_category_get()); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_date_created), settings->genconfig.notes_display_date_created_get()); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_created_by), settings->genconfig.notes_display_created_by_get()); // Notes text display. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_summary), settings->genconfig.notes_display_summary_get()); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_add_ref_text), settings->genconfig.notes_display_reference_text_get()); label_result = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_result")); Shortcuts shortcuts(0); InDialogHelp * indialoghelp = new InDialogHelp(dialog, gtkbuilder, &shortcuts, "view/project-notes"); shortcuts.process(); cancelbutton = indialoghelp->cancelbutton; okbutton = indialoghelp->okbutton; g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this)); gtk_widget_grab_default(okbutton); set_gui(); }
GtkWidget* create_Calculator (void) { GtkWidget *Calculator; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *frame1; GtkWidget *table2; GtkWidget *hbox5; GtkWidget *labelDOO; GtkWidget *labelDuration; GtkWidget *hbox14; GtkWidget *label2; GtkWidget *hbox16; GtkWidget *label16; GtkWidget *entryCustom; GtkWidget *hbox21; GtkWidget *label14; GtkWidget *hbox18; GtkWidget *optionmenu2; GtkWidget *menu2; GtkWidget *avi1; GtkWidget *ogm1; GtkWidget *mpeg1; GtkWidget *hbox17; GtkWidget *optionmenu1; GtkWidget *menu1; GtkWidget *_1x80_cd1; GtkWidget *_2x80_cd1; GtkWidget *_1x74_cd1; GtkWidget *_2x74_cd1; GtkWidget *dvd1; GtkWidget *custom1; GtkWidget *label1; GtkWidget *frame2; GtkWidget *hbox11; GtkWidget *hbox12; GtkWidget *label6; GtkWidget *entry3; GtkWidget *hbox13; GtkWidget *label7; GtkWidget *entry4; GtkWidget *label4; GtkWidget *frame3; GtkWidget *hbox20; GtkWidget *table3; GtkWidget *label9; GtkWidget *labelAudio; GtkWidget *label11; GtkWidget *labelVideo; GtkWidget *label17; GtkWidget *labelTotal; GtkWidget *table4; GtkWidget *label12; GtkWidget *label15; GtkWidget *labelBitrate; GtkWidget *labelBPP; GtkWidget *label8; GtkWidget *dialog_action_area1; GtkWidget *doit; GtkWidget *button1; GtkTooltips *tooltips; tooltips = gtk_tooltips_new (); Calculator = gtk_dialog_new (); gtk_container_set_border_width (GTK_CONTAINER (Calculator), 6); gtk_window_set_title (GTK_WINDOW (Calculator), _("Bitrate Calculator")); gtk_window_set_resizable (GTK_WINDOW (Calculator), FALSE); dialog_vbox1 = GTK_DIALOG (Calculator)->vbox; gtk_widget_show (dialog_vbox1); vbox1 = gtk_vbox_new (FALSE, 6); gtk_widget_show (vbox1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0); frame1 = gtk_frame_new (NULL); gtk_widget_show (frame1); gtk_box_pack_start (GTK_BOX (vbox1), frame1, FALSE, FALSE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE); table2 = gtk_table_new (3, 4, FALSE); gtk_widget_show (table2); gtk_container_add (GTK_CONTAINER (frame1), table2); gtk_container_set_border_width (GTK_CONTAINER (table2), 12); gtk_table_set_row_spacings (GTK_TABLE (table2), 6); gtk_table_set_col_spacings (GTK_TABLE (table2), 12); hbox5 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox5); gtk_table_attach (GTK_TABLE (table2), hbox5, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); labelDOO = gtk_label_new (_("Duration:")); gtk_widget_show (labelDOO); gtk_box_pack_start (GTK_BOX (hbox5), labelDOO, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (labelDOO), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelDOO), 0, 0.5); labelDuration = gtk_label_new (_("00:00:00")); gtk_widget_show (labelDuration); gtk_table_attach (GTK_TABLE (table2), labelDuration, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelDuration), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelDuration), 0, 0.5); hbox14 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox14); gtk_table_attach (GTK_TABLE (table2), hbox14, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label2 = gtk_label_new_with_mnemonic (_("_Medium:")); gtk_widget_show (label2); gtk_box_pack_start (GTK_BOX (hbox14), label2, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); hbox16 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox16); gtk_table_attach (GTK_TABLE (table2), hbox16, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label16 = gtk_label_new_with_mnemonic (_("_Format:")); gtk_widget_show (label16); gtk_box_pack_start (GTK_BOX (hbox16), label16, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label16), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5); entryCustom = gtk_entry_new (); gtk_widget_show (entryCustom); gtk_table_attach (GTK_TABLE (table2), entryCustom, 3, 4, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_tooltips_set_tip (tooltips, entryCustom, _("Total size (custom)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entryCustom), 10); gtk_entry_set_width_chars (GTK_ENTRY (entryCustom), 6); hbox21 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox21); gtk_table_attach (GTK_TABLE (table2), hbox21, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); label14 = gtk_label_new_with_mnemonic (_("_Custom size (MB):")); gtk_widget_show (label14); gtk_box_pack_start (GTK_BOX (hbox21), label14, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label14), GTK_JUSTIFY_LEFT); hbox18 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox18); gtk_table_attach (GTK_TABLE (table2), hbox18, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); optionmenu2 = gtk_option_menu_new (); gtk_widget_show (optionmenu2); gtk_box_pack_start (GTK_BOX (hbox18), optionmenu2, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, optionmenu2, _("Output container format"), NULL); menu2 = gtk_menu_new (); avi1 = gtk_menu_item_new_with_mnemonic (_("AVI")); gtk_widget_show (avi1); gtk_container_add (GTK_CONTAINER (menu2), avi1); ogm1 = gtk_menu_item_new_with_mnemonic (_("OGM")); gtk_widget_show (ogm1); gtk_container_add (GTK_CONTAINER (menu2), ogm1); mpeg1 = gtk_menu_item_new_with_mnemonic (_("MPEG")); gtk_widget_show (mpeg1); gtk_container_add (GTK_CONTAINER (menu2), mpeg1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu2), menu2); hbox17 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox17); gtk_table_attach (GTK_TABLE (table2), hbox17, 1, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); optionmenu1 = gtk_option_menu_new (); gtk_widget_show (optionmenu1); gtk_box_pack_start (GTK_BOX (hbox17), optionmenu1, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, optionmenu1, _("Total size"), NULL); menu1 = gtk_menu_new (); _1x80_cd1 = gtk_menu_item_new_with_mnemonic (_("1x 80 min. CD")); gtk_widget_show (_1x80_cd1); gtk_container_add (GTK_CONTAINER (menu1), _1x80_cd1); gtk_tooltips_set_tip (tooltips, _1x80_cd1, _("Total size (custom)"), NULL); _2x80_cd1 = gtk_menu_item_new_with_mnemonic (_("2x 80 min. CD")); gtk_widget_show (_2x80_cd1); gtk_container_add (GTK_CONTAINER (menu1), _2x80_cd1); _1x74_cd1 = gtk_menu_item_new_with_mnemonic (_("1x 74 min. CD")); gtk_widget_show (_1x74_cd1); gtk_container_add (GTK_CONTAINER (menu1), _1x74_cd1); _2x74_cd1 = gtk_menu_item_new_with_mnemonic (_("2x 74 min. CD")); gtk_widget_show (_2x74_cd1); gtk_container_add (GTK_CONTAINER (menu1), _2x74_cd1); dvd1 = gtk_menu_item_new_with_mnemonic (_("DVD5")); gtk_widget_show (dvd1); gtk_container_add (GTK_CONTAINER (menu1), dvd1); custom1 = gtk_menu_item_new_with_mnemonic (_("Custom")); gtk_widget_show (custom1); gtk_container_add (GTK_CONTAINER (menu1), custom1); gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu1), menu1); label1 = gtk_label_new (_("<b>Target</b>")); gtk_widget_show (label1); gtk_frame_set_label_widget (GTK_FRAME (frame1), label1); gtk_label_set_use_markup (GTK_LABEL (label1), TRUE); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); frame2 = gtk_frame_new (NULL); gtk_widget_show (frame2); gtk_box_pack_start (GTK_BOX (vbox1), frame2, FALSE, FALSE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE); hbox11 = gtk_hbox_new (TRUE, 12); gtk_widget_show (hbox11); gtk_container_add (GTK_CONTAINER (frame2), hbox11); gtk_container_set_border_width (GTK_CONTAINER (hbox11), 12); hbox12 = gtk_hbox_new (FALSE, 6); gtk_widget_show (hbox12); gtk_box_pack_start (GTK_BOX (hbox11), hbox12, TRUE, TRUE, 0); label6 = gtk_label_new_with_mnemonic (_("Track _1:")); gtk_widget_show (label6); gtk_box_pack_start (GTK_BOX (hbox12), label6, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label6), GTK_JUSTIFY_LEFT); entry3 = gtk_entry_new (); gtk_widget_show (entry3); gtk_box_pack_start (GTK_BOX (hbox12), entry3, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, entry3, _("Audio bitrate in kb/s for track 1 (0 for no audio)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entry3), 10); gtk_entry_set_width_chars (GTK_ENTRY (entry3), 6); hbox13 = gtk_hbox_new (FALSE, 6); gtk_widget_show (hbox13); gtk_box_pack_start (GTK_BOX (hbox11), hbox13, TRUE, TRUE, 0); label7 = gtk_label_new_with_mnemonic (_("Track _2: ")); gtk_widget_show (label7); gtk_box_pack_start (GTK_BOX (hbox13), label7, FALSE, FALSE, 0); gtk_label_set_justify (GTK_LABEL (label7), GTK_JUSTIFY_LEFT); entry4 = gtk_entry_new (); gtk_widget_show (entry4); gtk_box_pack_start (GTK_BOX (hbox13), entry4, TRUE, TRUE, 0); gtk_tooltips_set_tip (tooltips, entry4, _("Audio bitrate in kb/s for track 2 (optional)"), NULL); gtk_entry_set_max_length (GTK_ENTRY (entry4), 10); gtk_entry_set_width_chars (GTK_ENTRY (entry4), 6); label4 = gtk_label_new (_("<b>Audio Bitrate</b>")); gtk_widget_show (label4); gtk_frame_set_label_widget (GTK_FRAME (frame2), label4); gtk_label_set_use_markup (GTK_LABEL (label4), TRUE); gtk_label_set_justify (GTK_LABEL (label4), GTK_JUSTIFY_LEFT); frame3 = gtk_frame_new (NULL); gtk_widget_show (frame3); gtk_box_pack_start (GTK_BOX (vbox1), frame3, FALSE, FALSE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame3), GTK_SHADOW_NONE); hbox20 = gtk_hbox_new (TRUE, 12); gtk_widget_show (hbox20); gtk_container_add (GTK_CONTAINER (frame3), hbox20); gtk_container_set_border_width (GTK_CONTAINER (hbox20), 12); table3 = gtk_table_new (3, 2, FALSE); gtk_widget_show (table3); gtk_box_pack_start (GTK_BOX (hbox20), table3, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table3), 6); gtk_table_set_col_spacings (GTK_TABLE (table3), 6); label9 = gtk_label_new (_("Audio size (MB):")); gtk_widget_show (label9); gtk_table_attach (GTK_TABLE (table3), label9, 0, 1, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label9), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label9), 0, 0.5); labelAudio = gtk_label_new (_("0")); gtk_widget_show (labelAudio); gtk_table_attach (GTK_TABLE (table3), labelAudio, 1, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelAudio), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelAudio), 0, 0.5); label11 = gtk_label_new (_("Video size (MB):")); gtk_widget_show (label11); gtk_table_attach (GTK_TABLE (table3), label11, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label11), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label11), 0, 0.5); labelVideo = gtk_label_new (_("0")); gtk_widget_show (labelVideo); gtk_table_attach (GTK_TABLE (table3), labelVideo, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelVideo), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelVideo), 0, 0.5); label17 = gtk_label_new (_("Total size (MB):")); gtk_widget_show (label17); gtk_table_attach (GTK_TABLE (table3), label17, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label17), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label17), 0, 0.5); labelTotal = gtk_label_new (_("0")); gtk_widget_show (labelTotal); gtk_table_attach (GTK_TABLE (table3), labelTotal, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelTotal), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelTotal), 0, 0.5); table4 = gtk_table_new (2, 2, FALSE); gtk_widget_show (table4); gtk_box_pack_start (GTK_BOX (hbox20), table4, TRUE, TRUE, 0); gtk_table_set_row_spacings (GTK_TABLE (table4), 6); gtk_table_set_col_spacings (GTK_TABLE (table4), 6); label12 = gtk_label_new (_("Video bitrate:")); gtk_widget_show (label12); gtk_table_attach (GTK_TABLE (table4), label12, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label12), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label12), 0, 0.5); label15 = gtk_label_new (_("Bits per pixel:")); gtk_widget_show (label15); gtk_table_attach (GTK_TABLE (table4), label15, 0, 1, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (label15), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5); labelBitrate = gtk_label_new (_("0")); gtk_widget_show (labelBitrate); gtk_table_attach (GTK_TABLE (table4), labelBitrate, 1, 2, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelBitrate), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelBitrate), 0, 0.5); labelBPP = gtk_label_new (_("0.0")); gtk_widget_show (labelBPP); gtk_table_attach (GTK_TABLE (table4), labelBPP, 1, 2, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify (GTK_LABEL (labelBPP), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment (GTK_MISC (labelBPP), 0, 0.5); label8 = gtk_label_new (_("<b>Result</b>")); gtk_widget_show (label8); gtk_frame_set_label_widget (GTK_FRAME (frame3), label8); gtk_label_set_use_markup (GTK_LABEL (label8), TRUE); gtk_label_set_justify (GTK_LABEL (label8), GTK_JUSTIFY_LEFT); dialog_action_area1 = GTK_DIALOG (Calculator)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); doit = gtk_button_new_from_stock ("gtk-apply"); gtk_widget_show (doit); gtk_dialog_add_action_widget (GTK_DIALOG (Calculator), doit, GTK_RESPONSE_APPLY); GTK_WIDGET_SET_FLAGS (doit, GTK_CAN_DEFAULT); button1 = gtk_button_new_from_stock ("gtk-close"); gtk_widget_show (button1); gtk_dialog_add_action_widget (GTK_DIALOG (Calculator), button1, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT); gtk_label_set_mnemonic_widget (GTK_LABEL (label2), optionmenu1); gtk_label_set_mnemonic_widget (GTK_LABEL (label16), optionmenu2); gtk_label_set_mnemonic_widget (GTK_LABEL (label14), entryCustom); gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry3); gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry4); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (Calculator, Calculator, "Calculator"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (Calculator, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (Calculator, frame1, "frame1"); GLADE_HOOKUP_OBJECT (Calculator, table2, "table2"); GLADE_HOOKUP_OBJECT (Calculator, hbox5, "hbox5"); GLADE_HOOKUP_OBJECT (Calculator, labelDOO, "labelDOO"); GLADE_HOOKUP_OBJECT (Calculator, labelDuration, "labelDuration"); GLADE_HOOKUP_OBJECT (Calculator, hbox14, "hbox14"); GLADE_HOOKUP_OBJECT (Calculator, label2, "label2"); GLADE_HOOKUP_OBJECT (Calculator, hbox16, "hbox16"); GLADE_HOOKUP_OBJECT (Calculator, label16, "label16"); GLADE_HOOKUP_OBJECT (Calculator, entryCustom, "entryCustom"); GLADE_HOOKUP_OBJECT (Calculator, hbox21, "hbox21"); GLADE_HOOKUP_OBJECT (Calculator, label14, "label14"); GLADE_HOOKUP_OBJECT (Calculator, hbox18, "hbox18"); GLADE_HOOKUP_OBJECT (Calculator, optionmenu2, "optionmenu2"); GLADE_HOOKUP_OBJECT (Calculator, menu2, "menu2"); GLADE_HOOKUP_OBJECT (Calculator, avi1, "avi1"); GLADE_HOOKUP_OBJECT (Calculator, ogm1, "ogm1"); GLADE_HOOKUP_OBJECT (Calculator, mpeg1, "mpeg1"); GLADE_HOOKUP_OBJECT (Calculator, hbox17, "hbox17"); GLADE_HOOKUP_OBJECT (Calculator, optionmenu1, "optionmenu1"); GLADE_HOOKUP_OBJECT (Calculator, menu1, "menu1"); GLADE_HOOKUP_OBJECT (Calculator, _1x80_cd1, "_1x80_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _2x80_cd1, "_2x80_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _1x74_cd1, "_1x74_cd1"); GLADE_HOOKUP_OBJECT (Calculator, _2x74_cd1, "_2x74_cd1"); GLADE_HOOKUP_OBJECT (Calculator, dvd1, "dvd1"); GLADE_HOOKUP_OBJECT (Calculator, custom1, "custom1"); GLADE_HOOKUP_OBJECT (Calculator, label1, "label1"); GLADE_HOOKUP_OBJECT (Calculator, frame2, "frame2"); GLADE_HOOKUP_OBJECT (Calculator, hbox11, "hbox11"); GLADE_HOOKUP_OBJECT (Calculator, hbox12, "hbox12"); GLADE_HOOKUP_OBJECT (Calculator, label6, "label6"); GLADE_HOOKUP_OBJECT (Calculator, entry3, "entry3"); GLADE_HOOKUP_OBJECT (Calculator, hbox13, "hbox13"); GLADE_HOOKUP_OBJECT (Calculator, label7, "label7"); GLADE_HOOKUP_OBJECT (Calculator, entry4, "entry4"); GLADE_HOOKUP_OBJECT (Calculator, label4, "label4"); GLADE_HOOKUP_OBJECT (Calculator, frame3, "frame3"); GLADE_HOOKUP_OBJECT (Calculator, hbox20, "hbox20"); GLADE_HOOKUP_OBJECT (Calculator, table3, "table3"); GLADE_HOOKUP_OBJECT (Calculator, label9, "label9"); GLADE_HOOKUP_OBJECT (Calculator, labelAudio, "labelAudio"); GLADE_HOOKUP_OBJECT (Calculator, label11, "label11"); GLADE_HOOKUP_OBJECT (Calculator, labelVideo, "labelVideo"); GLADE_HOOKUP_OBJECT (Calculator, label17, "label17"); GLADE_HOOKUP_OBJECT (Calculator, labelTotal, "labelTotal"); GLADE_HOOKUP_OBJECT (Calculator, table4, "table4"); GLADE_HOOKUP_OBJECT (Calculator, label12, "label12"); GLADE_HOOKUP_OBJECT (Calculator, label15, "label15"); GLADE_HOOKUP_OBJECT (Calculator, labelBitrate, "labelBitrate"); GLADE_HOOKUP_OBJECT (Calculator, labelBPP, "labelBPP"); GLADE_HOOKUP_OBJECT (Calculator, label8, "label8"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (Calculator, doit, "doit"); GLADE_HOOKUP_OBJECT (Calculator, button1, "button1"); GLADE_HOOKUP_OBJECT_NO_REF (Calculator, tooltips, "tooltips"); gtk_widget_grab_focus (entry3); return Calculator; }
GtkWidget *plugin_configure(GtkDialog *dialog) { GtkWidget *vbox, *label, *notebook_vbox, *checkbox_enable; GtkWidget *notebook, *inner_vbox; vbox = gtk_vbox_new(FALSE, 6); notebook = gtk_notebook_new(); GTK_WIDGET_UNSET_FLAGS(notebook, GTK_CAN_FOCUS); gtk_container_set_border_width(GTK_CONTAINER(notebook), 5); gtk_box_pack_start(GTK_BOX(vbox), notebook, FALSE, TRUE, 0); /* * Auto Save */ { GtkWidget *spin, *hbox, *checkbox, *radio1, *radio2; notebook_vbox = gtk_vbox_new(FALSE, 2); inner_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5); gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5); gtk_notebook_insert_page(GTK_NOTEBOOK(notebook), notebook_vbox, gtk_label_new(_("Auto Save")), NOTEBOOK_PAGE_AUTOSAVE); checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable")); gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE); pref_widgets.checkbox_enable_autosave = checkbox_enable; gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_autosave); g_signal_connect(checkbox_enable, "toggled", G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_AUTOSAVE)); label = gtk_label_new_with_mnemonic(_("Auto save _interval:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_container_add(GTK_CONTAINER(inner_vbox), label); pref_widgets.autosave_interval_spin = spin = gtk_spin_button_new_with_range(1, 1800, 1); gtk_spin_button_set_value(GTK_SPIN_BUTTON(spin), autosave_interval); gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin); label = gtk_label_new(_("seconds")); hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), spin, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(inner_vbox), hbox, FALSE, FALSE, 5); checkbox = gtk_check_button_new_with_mnemonic( _("_Print status message if files have been automatically saved")); gtk_button_set_focus_on_click(GTK_BUTTON(checkbox), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), autosave_print_msg); gtk_label_set_mnemonic_widget(GTK_LABEL(label), checkbox); gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox, FALSE, FALSE, 5); pref_widgets.autosave_print_msg_checkbox = checkbox; radio1 = gtk_radio_button_new_with_mnemonic(NULL, _("Save only current open _file")); pref_widgets.autosave_save_all_radio1 = radio1; gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio1); gtk_button_set_focus_on_click(GTK_BUTTON(radio1), FALSE); gtk_container_add(GTK_CONTAINER(inner_vbox), radio1); radio2 = gtk_radio_button_new_with_mnemonic_from_widget( GTK_RADIO_BUTTON(radio1), _("Sa_ve all open files")); pref_widgets.autosave_save_all_radio2 = radio2; gtk_label_set_mnemonic_widget(GTK_LABEL(label), radio2); gtk_button_set_focus_on_click(GTK_BUTTON(radio2), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), autosave_save_all); gtk_container_add(GTK_CONTAINER(inner_vbox), radio2); } /* * Instant Save */ { GtkWidget *combo; guint i; const GSList *node; notebook_vbox = gtk_vbox_new(FALSE, 2); inner_vbox = gtk_vbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(inner_vbox), 5); gtk_box_pack_start(GTK_BOX(notebook_vbox), inner_vbox, TRUE, TRUE, 5); gtk_notebook_insert_page(GTK_NOTEBOOK(notebook), notebook_vbox, gtk_label_new(_("Instant Save")), NOTEBOOK_PAGE_INSTANTSAVE); checkbox_enable = gtk_check_button_new_with_mnemonic(_("_Enable")); pref_widgets.checkbox_enable_instantsave = checkbox_enable; gtk_button_set_focus_on_click(GTK_BUTTON(checkbox_enable), FALSE); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox_enable), enable_instantsave); gtk_box_pack_start(GTK_BOX(inner_vbox), checkbox_enable, FALSE, FALSE, 6); g_signal_connect(checkbox_enable, "toggled", G_CALLBACK(checkbox_toggled_cb), GINT_TO_POINTER(NOTEBOOK_PAGE_INSTANTSAVE)); label = gtk_label_new_with_mnemonic(_("_Filetype to use for newly opened files:")); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(inner_vbox), label, FALSE, FALSE, 0); pref_widgets.instantsave_ft_combo = combo = gtk_combo_box_new_text(); i = 0; foreach_slist(node, filetypes_get_sorted_by_name()) { GeanyFiletype *ft = node->data; gtk_combo_box_append_text(GTK_COMBO_BOX(combo), ft->name); if (utils_str_equal(ft->name, instantsave_default_ft)) gtk_combo_box_set_active(GTK_COMBO_BOX(combo), i); i++; } gtk_combo_box_set_wrap_width(GTK_COMBO_BOX(combo), 3); gtk_label_set_mnemonic_widget(GTK_LABEL(label), combo); gtk_box_pack_start(GTK_BOX(inner_vbox), combo, FALSE, FALSE, 0); }
// Entry, combo, entry. void ResourceConverterDialog::build_entry_combo_entry(GtkWidget * &image_ok, GtkWidget * &label_ok, GtkWidget * &label, GtkWidget * &label_entry_1, GtkWidget * &entry_1, GtkWidget * &label_combo, GtkWidget * &combo, GtkWidget * &label_entry_2, GtkWidget * &entry_2, GCallback entry_handler, Shortcuts & shortcuts) { GtkWidget *hseparator; hseparator = gtk_hseparator_new(); gtk_widget_show(hseparator); gtk_table_attach(GTK_TABLE(table1), hseparator, 0, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); table_attachment_offset++; image_ok = gtk_image_new_from_icon_name("gtk-apply", GTK_ICON_SIZE_BUTTON); gtk_widget_show(image_ok); gtk_table_attach(GTK_TABLE(table1), image_ok, 0, 1, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); label_ok = gtk_label_new(_("Done")); gtk_widget_show(label_ok); gtk_table_attach(GTK_TABLE(table1), label_ok, 1, 2, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label_ok), 0, 0.5); label = gtk_label_new(""); gtk_widget_show(label); gtk_table_attach(GTK_TABLE(table1), label, 2, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); table_attachment_offset++; GtkWidget *hbox; hbox = gtk_hbox_new(FALSE, 5); gtk_widget_show(hbox); gtk_table_attach(GTK_TABLE(table1), hbox, 0, 4, table_attachment_offset, table_attachment_offset + 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0); table_attachment_offset++; label_entry_1 = gtk_label_new(""); gtk_widget_show(label_entry_1); gtk_box_pack_start(GTK_BOX(hbox), label_entry_1, FALSE, FALSE, 0); entry_1 = gtk_entry_new(); gtk_widget_show(entry_1); gtk_box_pack_start(GTK_BOX(hbox), entry_1, TRUE, TRUE, 0); shortcuts.label(label_entry_1); gtk_label_set_mnemonic_widget(GTK_LABEL(label_entry_1), entry_1); label_combo = gtk_label_new(""); gtk_widget_show(label_combo); gtk_box_pack_start(GTK_BOX(hbox), label_combo, FALSE, FALSE, 0); combo = gtk_combo_box_new_text(); gtk_widget_show(combo); gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, TRUE, 0); shortcuts.label(label_combo); gtk_label_set_mnemonic_widget(GTK_LABEL(label_combo), combo); label_entry_2 = gtk_label_new(""); gtk_widget_show(label_entry_2); gtk_box_pack_start(GTK_BOX(hbox), label_entry_2, FALSE, FALSE, 0); entry_2 = gtk_entry_new(); gtk_widget_show(entry_2); gtk_box_pack_start(GTK_BOX(hbox), entry_2, TRUE, TRUE, 0); shortcuts.label(label_entry_2); gtk_label_set_mnemonic_widget(GTK_LABEL(label_entry_2), entry_2); g_signal_connect((gpointer) entry_1, "changed", entry_handler, gpointer(this)); g_signal_connect((gpointer) entry_2, "changed", entry_handler, gpointer(this)); }
static gboolean load_dialog (const gchar *filename) { GtkWidget *dialog; GtkWidget *frame; GtkWidget *hbox; GtkWidget *vbox; GtkWidget *image; GdkPixbuf *preview; GtkWidget *table; GtkWidget *table2; GtkWidget *abox; GtkWidget *res; GtkWidget *label; GtkWidget *spinbutton; GtkWidget *toggle; GtkWidget *toggle2; GtkObject *adj; gboolean run; GError *error = NULL; SvgLoadVals vals = { SVG_DEFAULT_RESOLUTION, - SVG_PREVIEW_SIZE, - SVG_PREVIEW_SIZE }; preview = load_rsvg_pixbuf (filename, &vals, &error); if (!preview) { /* Do not rely on librsvg setting GError on failure! */ g_message (_("Could not open '%s' for reading: %s"), gimp_filename_to_utf8 (filename), error ? error->message : _("Unknown reason")); return FALSE; } gimp_ui_init (PLUG_IN_BINARY, FALSE); /* Scalable Vector Graphics is SVG, should perhaps not be translated */ dialog = gimp_dialog_new (_("Render Scalable Vector Graphics"), PLUG_IN_BINARY, NULL, 0, gimp_standard_help_func, LOAD_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); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gimp_window_set_transient (GTK_WINDOW (dialog)); hbox = gtk_hbox_new (FALSE, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 12); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); /* The SVG preview */ vbox = gtk_vbox_new (FALSE, 6); gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); abox = gtk_alignment_new (0.5, 0.5, 0.0, 0.0); gtk_box_pack_start (GTK_BOX (vbox), abox, FALSE, FALSE, 0); gtk_widget_show (abox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (abox), frame); gtk_widget_show (frame); image = gtk_image_new_from_pixbuf (preview); gtk_container_add (GTK_CONTAINER (frame), image); gtk_widget_show (image); size_label = gtk_label_new (NULL); gtk_label_set_justify (GTK_LABEL (size_label), GTK_JUSTIFY_CENTER); gtk_misc_set_alignment (GTK_MISC (size_label), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (vbox), size_label, TRUE, TRUE, 4); gtk_widget_show (size_label); /* query the initial size after the size label is created */ vals.resolution = load_vals.resolution; load_rsvg_size (filename, &vals, NULL); svg_width = vals.width; svg_height = vals.height; table = gtk_table_new (7, 3, FALSE); gtk_table_set_row_spacings (GTK_TABLE (table), 6); gtk_table_set_col_spacings (GTK_TABLE (table), 6); gtk_table_set_row_spacing (GTK_TABLE (table), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2); gtk_box_pack_start (GTK_BOX (hbox), table, TRUE, TRUE, 0); gtk_widget_show (table); /* Width and Height */ label = gtk_label_new (_("Width:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); label = gtk_label_new (_("Height:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 0, 1, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); spinbutton = gimp_spin_button_new (&adj, 1, 1, 1, 1, 10, 1, 1, 2); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 1, 2, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); size = GIMP_SIZE_ENTRY (gimp_size_entry_new (1, GIMP_UNIT_PIXEL, "%a", TRUE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_SIZE)); gtk_table_set_col_spacing (GTK_TABLE (size), 1, 6); gimp_size_entry_add_field (size, GTK_SPIN_BUTTON (spinbutton), NULL); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (size), FALSE, FALSE, 0); gtk_widget_show (GTK_WIDGET (size)); gimp_size_entry_set_refval_boundaries (size, 0, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval_boundaries (size, 1, GIMP_MIN_IMAGE_SIZE, GIMP_MAX_IMAGE_SIZE); gimp_size_entry_set_refval (size, 0, svg_width); gimp_size_entry_set_refval (size, 1, svg_height); gimp_size_entry_set_resolution (size, 0, load_vals.resolution, FALSE); gimp_size_entry_set_resolution (size, 1, load_vals.resolution, FALSE); g_signal_connect (size, "value-changed", G_CALLBACK (load_dialog_size_callback), NULL); /* Scale ratio */ hbox = gtk_hbox_new (FALSE, 0); gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (hbox); table2 = gtk_table_new (2, 2, FALSE); gtk_table_set_col_spacing (GTK_TABLE (table2), 0, 2); gtk_table_set_row_spacing (GTK_TABLE (table2), 0, 4); gtk_box_pack_start (GTK_BOX (hbox), table2, FALSE, FALSE, 0); spinbutton = gimp_spin_button_new (&xadj, ratio_x, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) svg_width, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_width, 0.01, 0.1, 1, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 0, 1); gtk_widget_show (spinbutton); g_signal_connect (xadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_X ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); spinbutton = gimp_spin_button_new (&yadj, ratio_y, (gdouble) GIMP_MIN_IMAGE_SIZE / (gdouble) svg_height, (gdouble) GIMP_MAX_IMAGE_SIZE / (gdouble) svg_height, 0.01, 0.1, 1, 0.01, 4); gtk_entry_set_width_chars (GTK_ENTRY (spinbutton), 10); gtk_table_attach_defaults (GTK_TABLE (table2), spinbutton, 0, 1, 1, 2); gtk_widget_show (spinbutton); g_signal_connect (yadj, "value-changed", G_CALLBACK (load_dialog_ratio_callback), NULL); label = gtk_label_new_with_mnemonic (_("_Y ratio:")); gtk_label_set_mnemonic_widget (GTK_LABEL (label), spinbutton); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); /* the constrain ratio chainbutton */ constrain = gimp_chain_button_new (GIMP_CHAIN_RIGHT); gimp_chain_button_set_active (GIMP_CHAIN_BUTTON (constrain), TRUE); gtk_table_attach_defaults (GTK_TABLE (table2), constrain, 1, 2, 0, 2); gtk_widget_show (constrain); gimp_help_set_help_data (GIMP_CHAIN_BUTTON (constrain)->button, _("Constrain aspect ratio"), NULL); gtk_widget_show (table2); /* Resolution */ label = gtk_label_new (_("Resolution:")); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (label); res = gimp_size_entry_new (1, GIMP_UNIT_INCH, _("pixels/%a"), FALSE, FALSE, FALSE, 10, GIMP_SIZE_ENTRY_UPDATE_RESOLUTION); gtk_table_set_col_spacing (GTK_TABLE (res), 1, 6); gtk_table_attach (GTK_TABLE (table), res, 1, 2, 4, 5, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (res); /* don't let the resolution become too small, librsvg tends to crash with very small resolutions */ gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (res), 0, 5.0, GIMP_MAX_RESOLUTION); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (res), 0, load_vals.resolution); g_signal_connect (res, "value-changed", G_CALLBACK (load_dialog_resolution_callback), (gpointer) filename); /* Path Import */ toggle = gtk_check_button_new_with_mnemonic (_("Import _paths")); gtk_table_attach (GTK_TABLE (table), toggle, 0, 2, 5, 6, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_show (toggle); gimp_help_set_help_data (toggle, _("Import path elements of the SVG so they " "can be used with the GIMP path tool"), NULL); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), load_vals.import); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &load_vals.import); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_sensitive_update), NULL); toggle2 = gtk_check_button_new_with_mnemonic (_("Merge imported paths")); gtk_table_attach (GTK_TABLE (table), toggle2, 0, 2, 6, 7, GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0); gtk_widget_set_sensitive (toggle2, load_vals.import); gtk_widget_show (toggle2); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle2), load_vals.merge); g_signal_connect (toggle2, "toggled", G_CALLBACK (gimp_toggle_button_update), &load_vals.merge); g_object_set_data (G_OBJECT (toggle), "set_sensitive", toggle2); gtk_widget_show (dialog); run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK); if (run) { load_vals.width = ROUND (gimp_size_entry_get_refval (size, 0)); load_vals.height = ROUND (gimp_size_entry_get_refval (size, 1)); } gtk_widget_destroy (dialog); return run; }
static GtkDialog * pgd_demo_get_auth_dialog (GFile *uri_file) { GtkDialog *dialog; GtkWidget *content_area, *action_area; GtkWidget *entry_container; GtkWidget *password_entry; GtkWidget *hbox, *main_vbox, *vbox, *icon; GtkWidget *table; GtkWidget *label; gchar *format, *markup, *file_name; dialog = GTK_DIALOG (gtk_dialog_new ()); content_area = gtk_dialog_get_content_area (dialog); action_area = gtk_dialog_get_action_area (dialog); /* Set the dialog up with HIG properties */ gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (content_area), 2); /* 2 * 5 + 2 = 12 */ gtk_container_set_border_width (GTK_CONTAINER (action_area), 5); gtk_box_set_spacing (GTK_BOX (action_area), 6); gtk_window_set_title (GTK_WINDOW (dialog), "Enter password"); gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE); gtk_window_set_icon_name (GTK_WINDOW (dialog), GTK_STOCK_DIALOG_AUTHENTICATION); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_dialog_add_buttons (dialog, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, "_Unlock Document", GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (dialog, GTK_RESPONSE_OK); gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE); gtk_dialog_set_alternative_button_order (dialog, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); /* Build contents */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_set_border_width (GTK_CONTAINER (hbox), 5); gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0); gtk_widget_show (hbox); icon = gtk_image_new_from_stock (GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG); gtk_misc_set_alignment (GTK_MISC (icon), 0.5, 0.0); gtk_box_pack_start (GTK_BOX (hbox), icon, FALSE, FALSE, 0); gtk_widget_show (icon); main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18); gtk_box_pack_start (GTK_BOX (hbox), main_vbox, TRUE, TRUE, 0); gtk_widget_show (main_vbox); label = gtk_label_new (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); file_name = g_file_get_basename (uri_file); format = g_strdup_printf ("<span size=\"larger\" weight=\"bold\">%s</span>\n\n%s", "Password required", "The document “%s” is locked and requires a password before it can be opened."); markup = g_markup_printf_escaped (format, file_name); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (format); g_free (markup); g_free (file_name); gtk_box_pack_start (GTK_BOX (main_vbox), label, FALSE, FALSE, 0); gtk_widget_show (label); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); /* The table that holds the entries */ entry_container = gtk_alignment_new (0.0, 0.0, 1.0, 1.0); gtk_alignment_set_padding (GTK_ALIGNMENT (entry_container), 0, 0, 0, 0); gtk_box_pack_start (GTK_BOX (vbox), entry_container, FALSE, FALSE, 0); gtk_widget_show (entry_container); table = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (table), 12); gtk_grid_set_row_spacing (GTK_GRID (table), 6); gtk_container_add (GTK_CONTAINER (entry_container), table); gtk_widget_show (table); label = gtk_label_new_with_mnemonic ("_Password:"******"changed", G_CALLBACK (pgd_demo_auth_dialog_entry_changed), dialog); g_signal_connect (password_entry, "activate", G_CALLBACK (pgd_demo_auth_dialog_entry_activated), dialog); gtk_grid_attach (GTK_GRID (table), label, 0, 0, 1, 1); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (table), password_entry, 1, 0, 1, 1); gtk_widget_set_hexpand (password_entry, TRUE); gtk_widget_show (password_entry); gtk_label_set_mnemonic_widget (GTK_LABEL (label), password_entry); return dialog; }
static ProfileDialog * color_profile_dialog_new (GimpImage *image, GimpContext *context, GtkWidget *parent, GimpProgress *progress, gboolean convert) { ProfileDialog *dialog; GtkWidget *frame; GtkWidget *vbox; GtkWidget *expander; GtkWidget *label; GimpColorProfile *src_profile; g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_CONTEXT (context), NULL); g_return_val_if_fail (GTK_IS_WIDGET (parent), NULL); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), NULL); dialog = g_slice_new0 (ProfileDialog); dialog->image = image; dialog->progress = progress; dialog->config = image->gimp->config->color_management; dialog->convert = convert; if (saved_intent == -1) { dialog->intent = dialog->config->display_intent; dialog->bpc = (dialog->intent == GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC); } else { dialog->intent = saved_intent; dialog->bpc = saved_bpc; } if (convert) { dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("Convert to ICC Color Profile"), "gimp-image-color-profile-convert", NULL, _("Convert the image to a color profile"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_COLOR_PROFILE_CONVERT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_CONVERT, GTK_RESPONSE_OK, NULL); } else { dialog->dialog = gimp_viewable_dialog_new (GIMP_VIEWABLE (image), context, _("Assign ICC Color Profile"), "gimp-image-color-profile-assign", NULL, _("Assign a color profile to the image"), parent, gimp_standard_help_func, GIMP_HELP_IMAGE_COLOR_PROFILE_ASSIGN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Assign"), GTK_RESPONSE_OK, NULL); } gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog->dialog), GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), FALSE); g_object_weak_ref (G_OBJECT (dialog->dialog), (GWeakNotify) color_profile_dialog_free, dialog); g_signal_connect (dialog->dialog, "response", G_CALLBACK (color_profile_dialog_response), dialog); dialog->main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12); gtk_container_set_border_width (GTK_CONTAINER (dialog->main_vbox), 12); gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog->dialog))), dialog->main_vbox, TRUE, TRUE, 0); gtk_widget_show (dialog->main_vbox); frame = gimp_frame_new (_("Current Color Profile")); gtk_box_pack_start (GTK_BOX (dialog->main_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); src_profile = gimp_color_managed_get_color_profile (GIMP_COLOR_MANAGED (image)); label = gimp_color_profile_label_new (src_profile); gtk_container_add (GTK_CONTAINER (frame), label); gtk_widget_show (label); frame = gimp_frame_new (convert ? _("Convert to") : _("Assign")); gtk_box_pack_start (GTK_BOX (dialog->main_vbox), 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); dialog->combo = color_profile_combo_box_new (dialog); gtk_box_pack_start (GTK_BOX (vbox), dialog->combo, FALSE, FALSE, 0); gtk_widget_show (dialog->combo); expander = gtk_expander_new_with_mnemonic (_("Profile _details")); gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0); gtk_widget_show (expander); dialog->dest_view = gimp_color_profile_view_new (); gtk_container_add (GTK_CONTAINER (expander), dialog->dest_view); gtk_widget_show (dialog->dest_view); g_signal_connect (dialog->combo, "changed", G_CALLBACK (color_profile_dest_changed), dialog); color_profile_dest_changed (dialog->combo, dialog); if (convert) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget *combo; GtkWidget *toggle; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (dialog->main_vbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("_Rendering Intent:")); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); combo = gimp_enum_combo_box_new (GIMP_TYPE_COLOR_RENDERING_INTENT); gtk_box_pack_start (GTK_BOX (hbox), combo, TRUE, TRUE, 0); gtk_widget_show (combo); gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), dialog->intent, G_CALLBACK (gimp_int_combo_box_get_active), &dialog->intent); gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo); toggle = gtk_check_button_new_with_mnemonic (_("_Black Point Compensation")); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), dialog->bpc); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0); gtk_widget_show (toggle); g_signal_connect (toggle, "toggled", G_CALLBACK (gimp_toggle_button_update), &dialog->bpc); } return dialog; }
static GObject * display_constructor (GType type, guint n_construct_properties, GObjectConstructParam * construct_properties) { GObject * obj; GObjectClass * parent_class; Display * self; parent_class = G_OBJECT_CLASS (display_parent_class); obj = parent_class->constructor (type, n_construct_properties, construct_properties); self = DISPLAY (obj); { GtkLabel* _label0; GtkHBox* _hbox0; GtkLabel* _label1; GtkLabel* _label2; GtkLabel* _label3; GtkLabel* _tmp0_; GtkComboBox* _tmp1_; GtkHBox* _tmp2_; GtkLabel* _tmp3_; GtkSpinButton* _tmp4_; GtkLabel* _tmp5_; GtkSpinButton* _tmp6_; GtkLabel* _tmp7_; GtkSpinButton* _tmp8_; GtkVBox* _tmp9_; GtkVBox* _tmp10_; GtkVBox* _tmp11_; GtkVBox* _tmp12_; _label0 = NULL; _hbox0 = NULL; _label1 = NULL; _label2 = NULL; _label3 = NULL; _label0 = (_tmp0_ = g_object_ref_sink ((GtkLabel*) gtk_label_new_with_mnemonic ("Display data blocks as images using imagemagick")), _g_object_unref0 (_label0), _tmp0_); self->priv->cb = (_tmp1_ = g_object_ref_sink ((GtkComboBox*) gtk_combo_box_new_text ()), _g_object_unref0 (self->priv->cb), _tmp1_); _hbox0 = (_tmp2_ = g_object_ref_sink ((GtkHBox*) gtk_hbox_new (FALSE, 10)), _g_object_unref0 (_hbox0), _tmp2_); _label1 = (_tmp3_ = g_object_ref_sink ((GtkLabel*) gtk_label_new_with_mnemonic ("Width:")), _g_object_unref0 (_label1), _tmp3_); self->priv->width = (_tmp4_ = g_object_ref_sink ((GtkSpinButton*) gtk_spin_button_new_with_range ((double) 50, (double) 5000, (double) 2)), _g_object_unref0 (self->priv->width), _tmp4_); _label2 = (_tmp5_ = g_object_ref_sink ((GtkLabel*) gtk_label_new_with_mnemonic ("Height:")), _g_object_unref0 (_label2), _tmp5_); self->priv->height = (_tmp6_ = g_object_ref_sink ((GtkSpinButton*) gtk_spin_button_new_with_range ((double) 50, (double) 5000, (double) 2)), _g_object_unref0 (self->priv->height), _tmp6_); _label3 = (_tmp7_ = g_object_ref_sink ((GtkLabel*) gtk_label_new_with_mnemonic ("Depth:")), _g_object_unref0 (_label3), _tmp7_); self->priv->depth = (_tmp8_ = g_object_ref_sink ((GtkSpinButton*) gtk_spin_button_new_with_range ((double) 1, (double) 32, (double) 1)), _g_object_unref0 (self->priv->depth), _tmp8_); gtk_window_set_title ((GtkWindow*) self, "Display data blocks"); gtk_dialog_set_has_separator ((GtkDialog*) self, FALSE); gtk_container_set_border_width ((GtkContainer*) self, (guint) 5); g_object_set ((GtkWindow*) self, "default-width", 300, NULL); g_object_set ((GtkWindow*) self, "default-height", 80, NULL); g_signal_connect_object ((GtkDialog*) self, "response", (GCallback) _display_on_response_gtk_dialog_response, self, 0); g_signal_connect ((GtkObject*) self, "destroy", (GCallback) _gtk_main_quit_gtk_object_destroy, NULL); gtk_label_set_mnemonic_widget (_label0, (GtkWidget*) self->priv->cb); gtk_box_pack_start ((GtkBox*) (_tmp9_ = ((GtkDialog*) self)->vbox, GTK_IS_VBOX (_tmp9_) ? ((GtkVBox*) _tmp9_) : NULL), (GtkWidget*) _label0, FALSE, TRUE, (guint) 0); g_signal_connect_object (self->priv->cb, "changed", (GCallback) __lambda0__gtk_combo_box_changed, self, 0); gtk_box_pack_start ((GtkBox*) (_tmp10_ = ((GtkDialog*) self)->vbox, GTK_IS_VBOX (_tmp10_) ? ((GtkVBox*) _tmp10_) : NULL), (GtkWidget*) self->priv->cb, FALSE, TRUE, (guint) 0); gtk_label_set_mnemonic_widget (_label1, (GtkWidget*) self->priv->width); gtk_box_pack_start ((GtkBox*) _hbox0, (GtkWidget*) _label1, FALSE, TRUE, (guint) 0); gtk_spin_button_set_value (self->priv->width, (double) 320); gtk_container_add ((GtkContainer*) _hbox0, (GtkWidget*) self->priv->width); gtk_label_set_mnemonic_widget (_label2, (GtkWidget*) self->priv->height); gtk_box_pack_start ((GtkBox*) _hbox0, (GtkWidget*) _label2, FALSE, TRUE, (guint) 0); gtk_spin_button_set_value (self->priv->height, (double) 240); gtk_container_add ((GtkContainer*) _hbox0, (GtkWidget*) self->priv->height); gtk_label_set_mnemonic_widget (_label3, (GtkWidget*) self->priv->depth); gtk_box_pack_start ((GtkBox*) _hbox0, (GtkWidget*) _label3, FALSE, TRUE, (guint) 0); gtk_spin_button_set_value (self->priv->depth, (double) 8); gtk_container_add ((GtkContainer*) _hbox0, (GtkWidget*) self->priv->depth); gtk_container_add ((GtkContainer*) (_tmp11_ = ((GtkDialog*) self)->vbox, GTK_IS_VBOX (_tmp11_) ? ((GtkVBox*) _tmp11_) : NULL), (GtkWidget*) _hbox0); gtk_box_set_spacing ((GtkBox*) (_tmp12_ = ((GtkDialog*) self)->vbox, GTK_IS_VBOX (_tmp12_) ? ((GtkVBox*) _tmp12_) : NULL), 10); _g_object_unref0 (_label0); _g_object_unref0 (_hbox0); _g_object_unref0 (_label1); _g_object_unref0 (_label2); _g_object_unref0 (_label3); } return obj; }
static void gimp_levels_tool_dialog (GimpImageMapTool *im_tool) { GimpLevelsTool *tool = GIMP_LEVELS_TOOL (im_tool); GimpToolOptions *tool_options = GIMP_TOOL_GET_OPTIONS (im_tool); GimpLevelsConfig *config = GIMP_LEVELS_CONFIG (im_tool->config); GtkListStore *store; GtkWidget *main_vbox; GtkWidget *frame_vbox; GtkWidget *vbox; GtkWidget *vbox2; GtkWidget *vbox3; GtkWidget *hbox; GtkWidget *hbox2; GtkWidget *label; GtkWidget *main_frame; GtkWidget *frame; GtkWidget *button; GtkWidget *spinbutton; GtkAdjustment *adjustment; GtkWidget *bar; GtkWidget *handle_bar; gint border; g_signal_connect (im_tool->settings_box, "file-dialog-setup", G_CALLBACK (gimp_levels_tool_export_setup), im_tool); main_vbox = gimp_image_map_tool_dialog_get_vbox (im_tool); /* The combo box for selecting channels */ main_frame = gimp_frame_new (NULL); gtk_box_pack_start (GTK_BOX (main_vbox), main_frame, TRUE, TRUE, 0); gtk_widget_show (main_frame); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_frame_set_label_widget (GTK_FRAME (main_frame), hbox); gtk_widget_show (hbox); label = gtk_label_new_with_mnemonic (_("Cha_nnel:")); gimp_label_set_attributes (GTK_LABEL (label), PANGO_ATTR_WEIGHT, PANGO_WEIGHT_BOLD, -1); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); gtk_widget_show (label); store = gimp_enum_store_new_with_range (GIMP_TYPE_HISTOGRAM_CHANNEL, GIMP_HISTOGRAM_VALUE, GIMP_HISTOGRAM_ALPHA); tool->channel_menu = gimp_enum_combo_box_new_with_model (GIMP_ENUM_STORE (store)); g_object_unref (store); gimp_enum_combo_box_set_icon_prefix (GIMP_ENUM_COMBO_BOX (tool->channel_menu), "gimp-channel"); gtk_box_pack_start (GTK_BOX (hbox), tool->channel_menu, FALSE, FALSE, 0); gtk_widget_show (tool->channel_menu); g_signal_connect (tool->channel_menu, "changed", G_CALLBACK (levels_channel_callback), tool); gtk_label_set_mnemonic_widget (GTK_LABEL (label), tool->channel_menu); button = gtk_button_new_with_mnemonic (_("R_eset Channel")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (levels_channel_reset_callback), tool); hbox2 = gimp_prop_enum_icon_box_new (G_OBJECT (tool_options), "histogram-scale", "gimp-histogram", 0, 0); gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); frame_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_container_add (GTK_CONTAINER (main_frame), frame_vbox); gtk_widget_show (frame_vbox); /* Input levels frame */ frame = gimp_frame_new (_("Input Levels")); gtk_box_pack_start (GTK_BOX (frame_vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0); gtk_widget_show (frame); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (frame), vbox2); gtk_widget_show (vbox2); tool->histogram_view = gimp_histogram_view_new (FALSE); gtk_box_pack_start (GTK_BOX (vbox2), tool->histogram_view, TRUE, TRUE, 0); gtk_widget_show (GTK_WIDGET (tool->histogram_view)); gimp_histogram_options_connect_view (GIMP_HISTOGRAM_OPTIONS (tool_options), GIMP_HISTOGRAM_VIEW (tool->histogram_view)); g_object_get (tool->histogram_view, "border-width", &border, NULL); vbox3 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox3), border); gtk_box_pack_start (GTK_BOX (vbox2), vbox3, FALSE, FALSE, 0); gtk_widget_show (vbox3); tool->input_bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL); gtk_widget_set_size_request (tool->input_bar, -1, GRADIENT_HEIGHT / 2); gtk_box_pack_start (GTK_BOX (vbox3), tool->input_bar, FALSE, FALSE, 0); gtk_widget_show (tool->input_bar); bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL); gtk_widget_set_size_request (bar, -1, GRADIENT_HEIGHT / 2); gtk_box_pack_start (GTK_BOX (vbox3), bar, FALSE, FALSE, 0); gtk_widget_show (bar); handle_bar = g_object_new (GIMP_TYPE_HANDLE_BAR, NULL); gtk_widget_set_size_request (handle_bar, -1, CONTROL_HEIGHT); gtk_box_pack_start (GTK_BOX (vbox3), handle_bar, FALSE, FALSE, 0); gtk_widget_show (handle_bar); gimp_handle_bar_connect_events (GIMP_HANDLE_BAR (handle_bar), tool->input_bar); gimp_handle_bar_connect_events (GIMP_HANDLE_BAR (handle_bar), bar); /* Horizontal box for input levels spinbuttons */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* low input spin */ hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_start (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); button = gimp_levels_tool_color_picker_new (tool, PICK_LOW_INPUT); gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0); gtk_widget_show (button); tool->low_input_spinbutton = spinbutton = gimp_prop_spin_button_new (im_tool->config, "low-input", 0.01, 0.1, 1); gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->low_input = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton)); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 0, tool->low_input); /* input gamma spin */ spinbutton = gimp_prop_spin_button_new (im_tool->config, "gamma", 0.01, 0.1, 2); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, TRUE, FALSE, 0); gimp_help_set_help_data (spinbutton, _("Gamma"), NULL); gtk_widget_show (spinbutton); tool->gamma = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton)); tool->gamma_linear = GTK_ADJUSTMENT (gtk_adjustment_new (127, 0, 255, 0.1, 1.0, 0.0)); g_signal_connect (tool->gamma_linear, "value-changed", G_CALLBACK (levels_linear_gamma_changed), tool); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 1, tool->gamma_linear); g_object_unref (tool->gamma_linear); /* high input spin */ hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2); gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, FALSE, 0); gtk_widget_show (hbox2); button = gimp_levels_tool_color_picker_new (tool, PICK_HIGH_INPUT); gtk_box_pack_start (GTK_BOX (hbox2), button, FALSE, FALSE, 0); gtk_widget_show (button); spinbutton = gimp_prop_spin_button_new (im_tool->config, "high-input", 0.01, 0.1, 1); gtk_box_pack_start (GTK_BOX (hbox2), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); tool->high_input_spinbutton = spinbutton; tool->high_input = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton)); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 2, tool->high_input); /* Output levels frame */ frame = gimp_frame_new (_("Output Levels")); gtk_box_pack_start (GTK_BOX (frame_vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_container_add (GTK_CONTAINER (frame), vbox); gtk_widget_show (vbox); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gtk_widget_show (frame); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox2), border); gtk_container_add (GTK_CONTAINER (frame), vbox2); gtk_widget_show (vbox2); tool->output_bar = g_object_new (GIMP_TYPE_COLOR_BAR, NULL); gtk_widget_set_size_request (tool->output_bar, -1, GRADIENT_HEIGHT); gtk_box_pack_start (GTK_BOX (vbox2), tool->output_bar, FALSE, FALSE, 0); gtk_widget_show (tool->output_bar); handle_bar = g_object_new (GIMP_TYPE_HANDLE_BAR, NULL); gtk_widget_set_size_request (handle_bar, -1, CONTROL_HEIGHT); gtk_box_pack_start (GTK_BOX (vbox2), handle_bar, FALSE, FALSE, 0); gtk_widget_show (handle_bar); gimp_handle_bar_connect_events (GIMP_HANDLE_BAR (handle_bar), tool->output_bar); /* Horizontal box for levels spin widgets */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* low output spin */ tool->low_output_spinbutton = spinbutton = gimp_prop_spin_button_new (im_tool->config, "low-output", 0.01, 0.1, 1); gtk_box_pack_start (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton)); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 0, adjustment); /* high output spin */ tool->high_output_spinbutton = spinbutton = gimp_prop_spin_button_new (im_tool->config, "high-output", 0.01, 0.1, 1); gtk_box_pack_end (GTK_BOX (hbox), spinbutton, FALSE, FALSE, 0); gtk_widget_show (spinbutton); adjustment = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spinbutton)); gimp_handle_bar_set_adjustment (GIMP_HANDLE_BAR (handle_bar), 2, adjustment); /* all channels frame */ main_frame = gimp_frame_new (_("All Channels")); gtk_box_pack_start (GTK_BOX (main_vbox), main_frame, FALSE, FALSE, 0); gtk_widget_show (main_frame); frame_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 4); gtk_container_add (GTK_CONTAINER (main_frame), frame_vbox); gtk_widget_show (frame_vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6); gtk_box_pack_start (GTK_BOX (frame_vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); button = gtk_button_new_with_mnemonic (_("_Auto Input Levels")); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, FALSE, 0); gimp_help_set_help_data (button, _("Adjust levels for all channels automatically"), NULL); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (levels_stretch_callback), tool); button = gimp_levels_tool_color_picker_new (tool, PICK_HIGH_INPUT | PICK_ALL_CHANNELS); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gimp_levels_tool_color_picker_new (tool, PICK_GAMMA | PICK_ALL_CHANNELS); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gimp_levels_tool_color_picker_new (tool, PICK_LOW_INPUT | PICK_ALL_CHANNELS); gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0); gtk_widget_show (button); button = gimp_icon_button_new (GIMP_STOCK_TOOL_CURVES, _("Edit these Settings as Curves")); gtk_box_pack_start (GTK_BOX (main_vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); g_signal_connect (button, "clicked", G_CALLBACK (levels_to_curves_callback), tool); gimp_int_combo_box_set_active (GIMP_INT_COMBO_BOX (tool->channel_menu), config->channel); }