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);
}