static void
script_fu_console_interface (void)
{
GtkWidget *dlg;
GtkWidget *button;
GtkWidget *label;
GtkWidget *vsb;
GtkWidget *table;
GtkWidget *hbox;
GIOChannel *input_channel;
INIT_I18N_UI();
textdomain("cinepaint-script-fu");
gimp_ui_init ("script-fu", FALSE);
dlg = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dlg), _("Script-Fu Console"));
gimp_help_connect_help_accel (dlg, gimp_standard_help_func,
"filters/script-fu.html");
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
(GtkSignalFunc) script_fu_close_callback,
NULL);
gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
GTK_SIGNAL_FUNC (gtk_widget_destroyed),
&dlg);
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->vbox), 2);
gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dlg)->action_area), 0);
/* Action area */
button = gtk_button_new_with_label (_("Close"));
gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) gtk_widget_destroy,
(gpointer)dlg);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->action_area), button, TRUE, TRUE, 0);
gtk_widget_show (button);
/* The info vbox */
label = gtk_label_new (_("SIOD Output"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
/* The output text widget */
cint.vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
vsb = gtk_vscrollbar_new (cint.vadj);
cint.console = gtk_text_new (NULL, cint.vadj);
gtk_text_set_editable (GTK_TEXT (cint.console), FALSE);
gtk_widget_set_usize (cint.console, TEXT_WIDTH, TEXT_HEIGHT);
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), table, TRUE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table), vsb, 1, 2, 0, 1,
0, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), cint.console, 0, 1, 0, 1,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
cint.font_strong = gdk_font_load ("-*-helvetica-bold-r-normal-*-*-120-*-*-*-*-*-*");
cint.font_emphasis = gdk_font_load ("-*-helvetica-medium-o-normal-*-*-100-*-*-*-*-*-*");
cint.font_weak = gdk_font_load ("-*-helvetica-medium-r-normal-*-*-100-*-*-*-*-*-*");
cint.font = gdk_fontset_load ("-*-*-medium-r-normal-*-*-100-*-*-c-*-iso8859-1,*");
/* Realize the widget before allowing new text to be inserted */
gtk_widget_realize (cint.console);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_strong, NULL, NULL,
"The GIMP - GNU Image Manipulation Program\n\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_emphasis, NULL, NULL,
"Copyright (C) 1995-2001\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_emphasis, NULL, NULL,
"Spencer Kimball, Peter Mattis and the GIMP Development Team\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"This program is free software; you can redistribute it and/or modify\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"it under the terms of the GNU General Public License as published by\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"the Free Software Foundation; either version 2 of the License, or\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"(at your option) any later version.\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"This program is distributed in the hope that it will be useful,\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"See the GNU General Public License for more details.\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"You should have received a copy of the GNU General Public License\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"along with this program; if not, write to the Free Software\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_strong, NULL, NULL,
"Welcome to SIOD, Scheme In One Defun\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"(C) Copyright 1988-1994 Paradigm Associates Inc.\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_weak, NULL, NULL,
"\n\n", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_strong, NULL, NULL,
"Script-Fu Console - ", -1);
gtk_text_insert (GTK_TEXT (cint.console), cint.font_emphasis, NULL, NULL,
"Interactive Scheme Development\n\n", -1);
gtk_widget_show (vsb);
gtk_widget_show (cint.console);
gtk_widget_show (table);
/* The current command */
label = gtk_label_new (_("Current Command"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), label, FALSE, TRUE, 0);
gtk_widget_show (label);
hbox = gtk_hbox_new ( FALSE, 0 );
gtk_widget_set_usize (hbox, ENTRY_WIDTH, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dlg)->vbox), hbox, FALSE, TRUE, 0);
gtk_widget_show (hbox);
cint.cc = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), cint.cc,
TRUE, TRUE, 0);
/* gtk_widget_set_usize (cint.cc, (ENTRY_WIDTH*5)/6, 0); */
GTK_WIDGET_SET_FLAGS (cint.cc, GTK_CAN_DEFAULT);
gtk_widget_grab_default (cint.cc);
gtk_signal_connect (GTK_OBJECT (cint.cc), "key_press_event",
(GtkSignalFunc) script_fu_cc_key_function,
NULL);
button = gtk_button_new_with_label (_("Browse..."));
/* gtk_widget_set_usize (button, (ENTRY_WIDTH)/6, 0); */
gtk_box_pack_start (GTK_BOX (hbox), button,
FALSE, TRUE, 0);
gtk_signal_connect (GTK_OBJECT (button), "clicked",
(GtkSignalFunc) script_fu_browse_callback,
NULL);
gtk_widget_show (button);
gtk_widget_show (cint.cc);
input_channel = g_io_channel_unix_new (siod_output_pipe[0]);
cint.input_id = g_io_add_watch (input_channel,
G_IO_IN,
script_fu_siod_read,
NULL);
/* Initialize the history */
history = g_list_append (history, NULL);
history_len = 1;
gtk_widget_show (dlg);
gtk_main ();
g_source_remove (cint.input_id);
if (dlg)
gtk_widget_destroy (dlg);
gdk_flush ();
}
GtkWidget *
gnome_prefs_scale_new (GtkWidget *table,
const gchar *down_label_txt,
const gchar *up_label_txt,
const gchar *conf_key,
const gchar *tooltip,
double min,
double max,
double step,
int row)
{
GnomePrefsWindow *gpw = NULL;
GtkWidget *hbox = NULL;
GtkAdjustment *adj = NULL;
GtkWidget *label = NULL;
GtkWidget *hscale = NULL;
gboolean writable = FALSE;
writable = gm_conf_is_key_writable (conf_key);
hbox = gtk_hbox_new (FALSE, 0);
label = gtk_label_new_with_mnemonic (down_label_txt);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE,
1 * 2);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
adj = (GtkAdjustment *)
gtk_adjustment_new (gm_conf_get_int (conf_key),
min, max, step,
2.0, 1.0);
hscale = gtk_hscale_new (adj);
gtk_scale_set_draw_value (GTK_SCALE (hscale), FALSE);
gtk_widget_set_size_request (GTK_WIDGET (hscale), 150, -1);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (hscale), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), hscale, FALSE, FALSE,
1 * 2);
label = gtk_label_new_with_mnemonic (up_label_txt);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE,
1 * 2);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 1, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
gpw = (GnomePrefsWindow *) g_object_get_data (G_OBJECT (table), "gpw");
if (gpw && tooltip)
gtk_widget_set_tooltip_text (hscale, tooltip);
g_signal_connect (adj, "value-changed",
G_CALLBACK (adjustment_changed),
(gpointer) conf_key);
gm_conf_notifier_add (conf_key, adjustment_changed_nt,
(gpointer) adj);
gtk_widget_show_all (table);
return hscale;
}
GtkWidget *
gnome_prefs_string_option_menu_new (GtkWidget *table,
const gchar *label_txt,
const gchar **options,
const gchar *conf_key,
const gchar *tooltip,
int row,
const gchar *default_value)
{
GnomePrefsWindow *gpw = NULL;
GtkWidget *label = NULL;
GtkWidget *option_menu = NULL;
GtkListStore *list_store = NULL;
GtkCellRenderer *renderer = NULL;
GtkTreeIter iter;
gchar *conf_string = NULL;
gboolean writable = FALSE;
int history = -1;
int cpt = 0;
writable = gm_conf_is_key_writable (conf_key);
label = gtk_label_new (label_txt);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
list_store = gtk_list_store_new (3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
option_menu = gtk_combo_box_new_with_model (GTK_TREE_MODEL (list_store));
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (option_menu), FALSE);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (option_menu), renderer, FALSE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (option_menu), renderer,
"text", COLUMN_STRING_TRANSLATED,
"sensitive", COLUMN_SENSITIVE,
NULL);
g_object_set (G_OBJECT (renderer),
"ellipsize-set", TRUE,
"ellipsize", PANGO_ELLIPSIZE_END,
"width-chars", 45, NULL);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), option_menu);
conf_string = gm_conf_get_string (conf_key);
if (conf_string == NULL)
conf_string = g_strdup (default_value);
while (options [cpt]) {
if (conf_string && !g_strcmp0 (conf_string, options [cpt]))
history = cpt;
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
COLUMN_STRING_RAW, options [cpt],
COLUMN_STRING_TRANSLATED, gettext (options [cpt]),
COLUMN_SENSITIVE, TRUE,
-1);
cpt++;
}
if (history == -1) {
if (conf_string && g_strcmp0 (conf_string, "")) {
gtk_list_store_append (GTK_LIST_STORE (list_store), &iter);
gtk_list_store_set (GTK_LIST_STORE (list_store), &iter,
COLUMN_STRING_RAW, conf_string,
COLUMN_STRING_TRANSLATED, gettext (conf_string),
COLUMN_SENSITIVE, FALSE,
-1);
history = cpt;
}
else
history = 0;
}
gtk_combo_box_set_active (GTK_COMBO_BOX (option_menu), history);
gtk_table_attach (GTK_TABLE (table), option_menu, 1, 2, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
gpw = (GnomePrefsWindow *) g_object_get_data (G_OBJECT (table), "gpw");
if (gpw && tooltip)
gtk_widget_set_tooltip_text (option_menu, tooltip);
g_signal_connect (option_menu, "changed",
G_CALLBACK (string_option_menu_changed),
(gpointer) conf_key);
gm_conf_notifier_add (conf_key, string_option_menu_changed_nt,
(gpointer) option_menu);
g_free (conf_string);
gtk_widget_show_all (table);
return option_menu;
}
/* create the "add" dialog. */
void
add_folder_cb (GtkWidget *widget,
void *callback_data)
{
GtkWidget *file_sel;
DialogData *data;
GtkWidget *main_box;
GtkWidget *vbox;
GtkWidget *table;
GtkWidget *align;
data = g_new0 (DialogData, 1);
data->settings = g_settings_new (ENGRAMPA_SCHEMA_ADD);
data->window = callback_data;
data->dialog = file_sel =
gtk_file_chooser_dialog_new (_("Add a Folder"),
GTK_WINDOW (data->window),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
FR_STOCK_ADD_FOLDER, GTK_RESPONSE_OK,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
NULL);
gtk_window_set_default_size (GTK_WINDOW (data->dialog), 530, 510);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (file_sel), FALSE);
gtk_dialog_set_default_response (GTK_DIALOG (file_sel), GTK_RESPONSE_OK);
data->add_if_newer_checkbutton = gtk_check_button_new_with_mnemonic (_("Add only if _newer"));
data->include_subfold_checkbutton = gtk_check_button_new_with_mnemonic (_("_Include subfolders"));
data->exclude_symlinks = gtk_check_button_new_with_mnemonic (_("Exclude folders that are symbolic lin_ks"));
data->include_files_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->include_files_entry, _("example: *.o; *.bak"));
data->include_files_label = gtk_label_new_with_mnemonic (_("Include _files:"));
gtk_misc_set_alignment (GTK_MISC (data->include_files_label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (data->include_files_label), data->include_files_entry);
data->exclude_files_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->exclude_files_entry, _("example: *.o; *.bak"));
data->exclude_files_label = gtk_label_new_with_mnemonic (_("E_xclude files:"));
gtk_misc_set_alignment (GTK_MISC (data->exclude_files_label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_files_label), data->exclude_files_entry);
data->exclude_folders_entry = gtk_entry_new ();
gtk_widget_set_tooltip_text (data->exclude_folders_entry, _("example: *.o; *.bak"));
data->exclude_folders_label = gtk_label_new_with_mnemonic (_("_Exclude folders:"));
gtk_misc_set_alignment (GTK_MISC (data->exclude_folders_label), 0.0, 0.5);
gtk_label_set_mnemonic_widget (GTK_LABEL (data->exclude_folders_label), data->exclude_folders_entry);
data->load_button = gtk_button_new_with_mnemonic (_("_Load Options"));
data->save_button = gtk_button_new_with_mnemonic (_("Sa_ve Options"));
data->clear_button = gtk_button_new_with_mnemonic (_("_Reset Options"));
main_box = gtk_hbox_new (FALSE, 20);
gtk_container_set_border_width (GTK_CONTAINER (main_box), 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (file_sel), main_box);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_box_pack_start (GTK_BOX (main_box), vbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->include_subfold_checkbutton,
TRUE, TRUE, 0);
align = gtk_alignment_new (0, 0, 0, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (align), 0, 0, 12, 0);
gtk_container_add (GTK_CONTAINER (align), data->exclude_symlinks);
gtk_box_pack_start (GTK_BOX (vbox), align, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->add_if_newer_checkbutton,
TRUE, TRUE, 0);
table = gtk_table_new (2, 4, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_box_pack_start (GTK_BOX (vbox), table,
TRUE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table),
data->include_files_label,
0, 1,
0, 1,
GTK_FILL, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->include_files_entry,
1, 4,
0, 1,
GTK_FILL|GTK_EXPAND, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->exclude_files_label,
0, 1,
1, 2,
GTK_FILL, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->exclude_files_entry,
1, 2,
1, 2,
GTK_FILL|GTK_EXPAND, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->exclude_folders_label,
2, 3,
1, 2,
GTK_FILL, 0,
0, 0);
gtk_table_attach (GTK_TABLE (table),
data->exclude_folders_entry,
3, 4,
1, 2,
GTK_FILL|GTK_EXPAND, 0,
0, 0);
/**/
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 0);
gtk_box_pack_start (GTK_BOX (main_box), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->load_button,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->save_button,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), data->clear_button,
FALSE, FALSE, 0);
gtk_widget_show_all (main_box);
/* set data */
dlg_add_folder_load_last_options (data);
/* signals */
g_signal_connect (G_OBJECT (file_sel),
"destroy",
G_CALLBACK (open_file_destroy_cb),
data);
g_signal_connect (G_OBJECT (file_sel),
"response",
G_CALLBACK (file_sel_response_cb),
data);
g_signal_connect (G_OBJECT (data->include_subfold_checkbutton),
"toggled",
G_CALLBACK (include_subfold_toggled_cb),
data);
g_signal_connect (G_OBJECT (data->load_button),
"clicked",
G_CALLBACK (load_options_cb),
data);
g_signal_connect (G_OBJECT (data->save_button),
"clicked",
G_CALLBACK (save_options_cb),
data);
g_signal_connect (G_OBJECT (data->clear_button),
"clicked",
G_CALLBACK (clear_options_cb),
data);
gtk_window_set_modal (GTK_WINDOW (file_sel),TRUE);
gtk_widget_show (file_sel);
}
GtkWidget*
gtr_torrent_options_dialog_new (GtkWindow * parent, TrCore * core, tr_ctor * ctor)
{
const char * str;
GtkWidget * w;
GtkWidget * d;
GtkGrid * grid;
int row;
GtkWidget * l;
GtkWidget * source_chooser;
struct OpenData * data;
bool flag;
GSList * list;
GSList * walk;
/* make the dialog */
d = gtk_dialog_new_with_buttons (_("Torrent Options"), parent,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (d),
GTK_RESPONSE_ACCEPT);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (d),
GTK_RESPONSE_ACCEPT,
GTK_RESPONSE_CANCEL,
-1);
if (!tr_ctorGetDownloadDir (ctor, TR_FORCE, &str))
g_assert_not_reached ();
g_assert (str);
data = g_new0 (struct OpenData, 1);
data->core = core;
data->ctor = ctor;
data->filename = g_strdup (tr_ctorGetSourceFile (ctor));
data->downloadDir = g_strdup (str);
data->file_list = gtr_file_list_new (core, 0);
str = _("Mo_ve .torrent file to the trash");
data->trash_check = gtk_check_button_new_with_mnemonic (str);
str = _("_Start when added");
data->run_check = gtk_check_button_new_with_mnemonic (str);
w = data->priority_combo = gtr_priority_combo_new ();
gtr_priority_combo_set_value (GTK_COMBO_BOX (w), TR_PRI_NORMAL);
g_signal_connect (G_OBJECT (d), "response",
G_CALLBACK (addResponseCB), data);
row = 0;
grid = GTK_GRID (gtk_grid_new ());
gtk_container_set_border_width (GTK_CONTAINER (grid), GUI_PAD_BIG);
gtk_grid_set_row_spacing (grid, GUI_PAD);
gtk_grid_set_column_spacing (grid, GUI_PAD_BIG);
/* "torrent file" row */
l = gtk_label_new_with_mnemonic (_("_Torrent file:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = gtk_file_chooser_button_new (_("Select Source File"),
GTK_FILE_CHOOSER_ACTION_OPEN);
source_chooser = w;
gtk_widget_set_hexpand (w, TRUE);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
addTorrentFilters (GTK_FILE_CHOOSER (w));
g_signal_connect (w, "selection-changed",
G_CALLBACK (sourceChanged), data);
/* "destination folder" row */
row++;
l = gtk_label_new_with_mnemonic (_("_Destination folder:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = gtk_file_chooser_button_new (_("Select Destination Folder"),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER);
if (!gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (w),
data->downloadDir))
g_warning ("couldn't select '%s'", data->downloadDir);
list = get_recent_destinations ();
for (walk = list; walk; walk = walk->next)
gtk_file_chooser_add_shortcut_folder (GTK_FILE_CHOOSER (w), walk->data, NULL);
g_slist_free (list);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
g_signal_connect (w, "selection-changed",
G_CALLBACK (downloadDirChanged), data);
row++;
l = data->freespace_label = gtr_freespace_label_new (core, data->downloadDir);
gtk_widget_set_margin_bottom (l, GUI_PAD_BIG);
gtk_misc_set_alignment (GTK_MISC (l), 1.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 2, 1);
/* file list row */
row++;
w = data->file_list;
gtk_widget_set_vexpand (w, TRUE);
gtk_widget_set_size_request (w, 466u, 300u);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* torrent priority row */
row++;
l = gtk_label_new_with_mnemonic (_("Torrent _priority:"));
gtk_misc_set_alignment (GTK_MISC (l), 0.0f, 0.5f);
gtk_grid_attach (grid, l, 0, row, 1, 1);
w = data->priority_combo;
gtk_label_set_mnemonic_widget (GTK_LABEL (l), w);
gtk_grid_attach_next_to (grid, w, l, GTK_POS_RIGHT, 1, 1);
/* torrent priority row */
row++;
w = data->run_check;
if (!tr_ctorGetPaused (ctor, TR_FORCE, &flag))
g_assert_not_reached ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), !flag);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* "trash .torrent file" row */
row++;
w = data->trash_check;
if (!tr_ctorGetDeleteSource (ctor, &flag))
g_assert_not_reached ();
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (w), flag);
gtk_grid_attach (grid, w, 0, row, 2, 1);
/* trigger sourceChanged, either directly or indirectly,
* so that it creates the tor/gtor objects */
w = source_chooser;
if (data->filename)
gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (w), data->filename);
else
sourceChanged (GTK_FILE_CHOOSER_BUTTON (w), data);
gtr_dialog_set_content (GTK_DIALOG (d), GTK_WIDGET (grid));
w = gtk_dialog_get_widget_for_response (GTK_DIALOG (d), GTK_RESPONSE_ACCEPT);
gtk_widget_grab_focus (w);
return d;
}
void
cal_notes_browser (GUI *appGUI)
{
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *scrolledwindow;
GtkWidget *hseparator;
GtkWidget *hbuttonbox;
GtkWidget *close_button;
GtkWidget *notes_tools_table;
GtkWidget *label;
GtkObject *notes_month_spinbutton_adj;
GtkObject *notes_year_spinbutton_adj;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
gchar tmpbuf[BUFFER_SIZE];
appGUI->cal->day_notes_list = NULL;
appGUI->cal->day_notes_list_store = NULL;
appGUI->cal->day_notes_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (appGUI->cal->day_notes_window), _("Calendar notes"));
gtk_window_set_position (GTK_WINDOW (appGUI->cal->day_notes_window), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_default_size (GTK_WINDOW(appGUI->cal->day_notes_window), config.cb_window_size_x, config.cb_window_size_y);
gtk_window_set_modal (GTK_WINDOW (appGUI->cal->day_notes_window), TRUE);
g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "delete_event",
G_CALLBACK(day_notes_window_close_cb), appGUI);
gtk_window_set_transient_for(GTK_WINDOW(appGUI->cal->day_notes_window), GTK_WINDOW(appGUI->main_window));
gtk_container_set_border_width (GTK_CONTAINER (appGUI->cal->day_notes_window), 8);
g_signal_connect (G_OBJECT (appGUI->cal->day_notes_window), "key_press_event",
G_CALLBACK (day_notes_key_press_cb), appGUI);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (appGUI->cal->day_notes_window), vbox1);
notes_tools_table = gtk_table_new (6, 3, FALSE);
gtk_widget_show (notes_tools_table);
gtk_box_pack_start (GTK_BOX (vbox1), notes_tools_table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (notes_tools_table), 3);
gtk_table_set_col_spacings (GTK_TABLE (notes_tools_table), 2);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 2);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 2);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_table_attach (GTK_TABLE (notes_tools_table), hseparator, 0, 3, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 2);
sprintf(tmpbuf, "<b>%s:</b>", _("Search"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_table_attach (GTK_TABLE (notes_tools_table), hbox1, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
notes_month_spinbutton_adj = gtk_adjustment_new (1, 1, 12, 1, 5, 0);
appGUI->cal->notes_month_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_month_spinbutton_adj), 1, 0);
gtk_widget_show (appGUI->cal->notes_month_spinbutton);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_month_spinbutton, TRUE, TRUE, 0);
g_signal_connect (appGUI->cal->notes_month_spinbutton, "value-changed",
G_CALLBACK (notes_filter_changed_cb), appGUI);
notes_year_spinbutton_adj = gtk_adjustment_new (utl_date_get_current_year (), 1, 9999, 1, 10, 0);
appGUI->cal->notes_year_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (notes_year_spinbutton_adj), 1, 0);
gtk_widget_show (appGUI->cal->notes_year_spinbutton);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->cal->notes_year_spinbutton, TRUE, TRUE, 0);
g_signal_connect (appGUI->cal->notes_year_spinbutton, "value-changed",
G_CALLBACK (notes_filter_changed_cb), appGUI);
sprintf(tmpbuf, "<b>%s:</b>", _("Filter"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (notes_tools_table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->cal->notes_filter_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->cal->notes_filter_combobox);
g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "focus",
G_CALLBACK(notes_filter_combo_box_focus_cb), NULL);
g_signal_connect(G_OBJECT(appGUI->cal->notes_filter_combobox), "changed",
G_CALLBACK(notes_filter_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_filter_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current month"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Current year"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected year"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("Selected month and year"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->cal->notes_filter_combobox), _("All notes"));
gtk_combo_box_set_active(GTK_COMBO_BOX(appGUI->cal->notes_filter_combobox), config.day_notes_browser_filter);
appGUI->cal->n_items_label = gtk_label_new ("");
gtk_widget_show (appGUI->cal->n_items_label);
gtk_widget_set_size_request (appGUI->cal->n_items_label, 100, -1);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->n_items_label, 2, 3, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (appGUI->cal->n_items_label), TRUE);
appGUI->cal->notes_search_entry = gtk_entry_new ();
gtk_widget_show (appGUI->cal->notes_search_entry);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_entry, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect (G_OBJECT (appGUI->cal->notes_search_entry), "key_press_event",
G_CALLBACK (search_entry_key_press_cb), appGUI);
appGUI->cal->notes_search_checkbutton = gtk_check_button_new_with_mnemonic (_("Case sensitive"));
gtk_widget_show (appGUI->cal->notes_search_checkbutton);
GTK_WIDGET_UNSET_FLAGS(appGUI->cal->notes_search_checkbutton, GTK_CAN_FOCUS);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->notes_search_checkbutton, 2, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
appGUI->cal->past_notes_checkbutton = gtk_check_button_new_with_mnemonic (_("Strikethrough past day notes"));
GTK_WIDGET_UNSET_FLAGS(appGUI->cal->past_notes_checkbutton, GTK_CAN_FOCUS);
g_signal_connect (G_OBJECT (appGUI->cal->past_notes_checkbutton), "toggled",
G_CALLBACK (browser_past_notes_cb), appGUI);
gtk_widget_show (appGUI->cal->past_notes_checkbutton);
gtk_table_attach (GTK_TABLE (notes_tools_table), appGUI->cal->past_notes_checkbutton, 0, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 2);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->cal->day_notes_list_store = gtk_list_store_new(DAY_NOTES_NUM_COLUMNS,
G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_BOOLEAN);
appGUI->cal->day_notes_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->cal->day_notes_list_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->cal->day_notes_list), TRUE);
gtk_widget_show (appGUI->cal->day_notes_list);
GTK_WIDGET_SET_FLAGS (appGUI->cal->day_notes_list, GTK_CAN_DEFAULT);
gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->cal->day_notes_list);
g_signal_connect(G_OBJECT(appGUI->cal->day_notes_list), "button_press_event",
G_CALLBACK(day_notes_list_dbclick_cb), appGUI);
appGUI->cal->day_notes_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->cal->day_notes_list));
/* create columns */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Date"), renderer,
"text", DN_COLUMN_DATE,
"strikethrough", DN_COLUMN_DONE,
NULL);
gtk_tree_view_column_set_visible (column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Julian", renderer,
"text", DN_COLUMN_DATE_JULIAN,
"strikethrough", DN_COLUMN_DONE,
NULL);
gtk_tree_view_column_set_visible (column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column);
gtk_tree_view_column_set_sort_column_id (column, DN_COLUMN_DATE_JULIAN);
g_signal_emit_by_name(column, "clicked");
if (config.ascending_sorting_in_day_notes_browser == FALSE) {
g_signal_emit_by_name(column, "clicked");
}
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes(_("Note"), renderer,
"text", DN_COLUMN_NOTE_LINE,
"strikethrough", DN_COLUMN_DONE,
NULL);
gtk_tree_view_column_set_visible (column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"text", DN_COLUMN_DONE,
NULL);
gtk_tree_view_column_set_visible (column, FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->cal->day_notes_list), column);
refresh_notes_list (config.day_notes_browser_filter, NULL, appGUI);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 4);
hbuttonbox = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox);
gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox), 4);
close_button = utl_gui_create_button (GTK_STOCK_CLOSE, OSMO_STOCK_BUTTON_CLOSE, _("Close"));
gtk_widget_show (close_button);
GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS);
g_signal_connect(close_button, "clicked", G_CALLBACK(button_day_notes_window_close_cb), appGUI);
gtk_container_add(GTK_CONTAINER(hbuttonbox), close_button);
gtk_widget_show(appGUI->cal->day_notes_window);
gtk_widget_grab_focus (appGUI->cal->day_notes_list);
}
void
properties_cb (GtkAction *action,
EyesApplet *eyes_applet)
{
GtkWidget *pbox, *hbox;
GtkWidget *vbox, *indent;
GtkWidget *categories_vbox;
GtkWidget *category_vbox, *control_vbox;
GtkWidget *tree;
GtkWidget *scrolled;
GtkWidget *label;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeSelection *selection;
GtkTreeIter iter;
DIR *dfd;
struct dirent *dp;
int i;
#ifdef PATH_MAX
gchar filename [PATH_MAX];
#else
gchar *filename;
#endif
gchar *title;
if (eyes_applet->prop_box.pbox) {
gtk_window_set_screen (
GTK_WINDOW (eyes_applet->prop_box.pbox),
gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet)));
gtk_window_present (GTK_WINDOW (eyes_applet->prop_box.pbox));
return;
}
pbox = gtk_dialog_new_with_buttons (_("Geyes Preferences"), NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
GTK_STOCK_HELP, GTK_RESPONSE_HELP,
NULL);
gtk_window_set_screen (GTK_WINDOW (pbox),
gtk_widget_get_screen (GTK_WIDGET (eyes_applet->applet)));
gtk_widget_set_size_request (GTK_WIDGET (pbox), 300, 200);
gtk_dialog_set_default_response(GTK_DIALOG (pbox), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator (GTK_DIALOG (pbox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (pbox), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), 2);
g_signal_connect (pbox, "response",
G_CALLBACK (presponse_cb),
eyes_applet);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (pbox))), vbox,
TRUE, TRUE, 0);
categories_vbox = gtk_vbox_new (FALSE, 18);
gtk_box_pack_start (GTK_BOX (vbox), categories_vbox, TRUE, TRUE, 0);
gtk_widget_show (categories_vbox);
category_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (categories_vbox), category_vbox, TRUE, TRUE, 0);
gtk_widget_show (category_vbox);
title = g_strconcat ("<span weight=\"bold\">", _("Themes"), "</span>", NULL);
label = gtk_label_new (_(title));
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (category_vbox), label, FALSE, FALSE, 0);
g_free (title);
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (category_vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
indent = gtk_label_new (HIG_IDENTATION);
gtk_label_set_justify (GTK_LABEL (indent), GTK_JUSTIFY_LEFT);
gtk_box_pack_start (GTK_BOX (hbox), indent, FALSE, FALSE, 0);
gtk_widget_show (indent);
control_vbox = gtk_vbox_new (FALSE, 6);
gtk_box_pack_start (GTK_BOX (hbox), control_vbox, TRUE, TRUE, 0);
gtk_widget_show (control_vbox);
label = gtk_label_new_with_mnemonic (_("_Select a theme:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (control_vbox), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
model = gtk_list_store_new (TOTAL_COLS, G_TYPE_STRING, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), tree);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (scrolled), tree);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("not used", cell,
"text", COL_THEME_NAME, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
g_signal_connect (selection, "changed",
G_CALLBACK (theme_selected_cb),
eyes_applet);
if ( ! g_settings_is_writable (eyes_applet->settings, "theme-path")) {
gtk_widget_set_sensitive (tree, FALSE);
gtk_widget_set_sensitive (label, FALSE);
}
for (i = 0; i < NUM_THEME_DIRECTORIES; i++) {
if ((dfd = opendir (theme_directories[i])) != NULL) {
while ((dp = readdir (dfd)) != NULL) {
if (dp->d_name[0] != '.') {
gchar *theme_dir;
gchar *theme_name;
#ifdef PATH_MAX
strcpy (filename,
theme_directories[i]);
strcat (filename, dp->d_name);
#else
asprintf (&filename, theme_directories[i], dp->d_name);
#endif
theme_dir = g_strdup_printf ("%s/", filename);
theme_name = g_path_get_basename (filename);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COL_THEME_DIR, &filename,
COL_THEME_NAME, theme_name,
-1);
if (!g_ascii_strncasecmp (eyes_applet->theme_dir, theme_dir, strlen (theme_dir))) {
GtkTreePath *path;
path = gtk_tree_model_get_path (GTK_TREE_MODEL (model),
&iter);
gtk_tree_view_set_cursor (GTK_TREE_VIEW (tree),
path,
NULL,
FALSE);
gtk_tree_path_free (path);
}
g_free (theme_name);
g_free (theme_dir);
}
}
closedir (dfd);
}
}
#ifndef PATH_MAX
g_free (filename);
#endif
gtk_box_pack_start (GTK_BOX (control_vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show_all (pbox);
eyes_applet->prop_box.pbox = pbox;
return;
}
/*
* CTK VCS (Visual Computing System) widget creation
*
*/
GtkWidget* ctk_vcs_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config)
{
GObject *object;
CtkVcs *ctk_object;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *event;
GtkWidget *banner;
GtkWidget *hseparator;
GtkWidget *table;
GtkWidget *scrollWin;
GtkWidget *checkbutton;
gchar *product_name;
gchar *serial_number;
gchar *build_date;
gchar *product_id;
gchar *firmware_version;
gchar *hardware_version;
gint current_row;
gboolean high_perf_mode;
ReturnStatus ret;
gchar *s;
char *psu_str = NULL;
PSUEntry psuEntry;
GtkWidget *vbox_scroll, *hbox_scroll;
/*
* get the static string data that we will display below
*/
/* Product Name */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_PRODUCT_NAME,
&product_name);
if (ret != NvCtrlSuccess) {
product_name = g_strdup("Unable to determine");
}
/* Serial Number */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_SERIAL_NUMBER,
&serial_number);
if (ret != NvCtrlSuccess) {
serial_number = g_strdup("Unable to determine");
}
/* Build Date */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_BUILD_DATE,
&build_date);
if (ret != NvCtrlSuccess) {
build_date = g_strdup("Unable to determine");
}
/* Product ID */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_PRODUCT_ID,
&product_id);
if (ret != NvCtrlSuccess) {
product_id = g_strdup("Unable to determine");
}
/* Firmware Version */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_FIRMWARE_VERSION,
&firmware_version);
if (ret != NvCtrlSuccess) {
firmware_version = g_strdup("Unable to determine");
}
/* Hardware Version */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_HARDWARE_VERSION,
&hardware_version);
if (ret != NvCtrlSuccess) {
hardware_version = g_strdup("Unable to determine");
}
/* now, create the object */
object = g_object_new(CTK_TYPE_VCS, NULL);
ctk_object = CTK_VCS(object);
/* cache the attribute handle */
ctk_object->handle = handle;
ctk_object->ctk_config = ctk_config;
/* set container properties of the object */
gtk_box_set_spacing(GTK_BOX(ctk_object), 10);
/* banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_VCS);
gtk_box_pack_start(GTK_BOX(ctk_object), banner, FALSE, FALSE, 0);
/*
* This displays basic System information, including
* display name, Operating system type and the NVIDIA driver version.
*/
vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(ctk_object), vbox, TRUE, TRUE, 0);
/* General purpose error dialog */
ctk_object->error_dialog = create_error_dialog(ctk_object);
if (NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE,
&high_perf_mode) == NvCtrlSuccess) {
hbox = gtk_hbox_new(FALSE, 0);
checkbutton = gtk_check_button_new_with_label("Enable High Performance Mode");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), high_perf_mode);
g_signal_connect(G_OBJECT(checkbutton), "toggled",
G_CALLBACK(vcs_perf_checkbox_toggled),
(gpointer) ctk_object);
gtk_box_pack_start(GTK_BOX(hbox), checkbutton, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
}
/* Create the Scrolling Window */
scrollWin = gtk_scrolled_window_new(NULL, NULL);
hbox_scroll = gtk_hbox_new(FALSE, 0);
vbox_scroll = gtk_vbox_new(FALSE, 5);
event = gtk_event_box_new();
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollWin),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_widget_modify_fg(event, GTK_STATE_NORMAL, &(event->style->text[GTK_STATE_NORMAL]));
gtk_widget_modify_bg(event, GTK_STATE_NORMAL, &(event->style->base[GTK_STATE_NORMAL]));
gtk_container_add(GTK_CONTAINER(event), hbox_scroll);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollWin),
event);
gtk_box_pack_start(GTK_BOX(hbox_scroll), vbox_scroll, TRUE, TRUE, 5);
gtk_widget_set_size_request(scrollWin, -1, 50);
gtk_box_pack_start(GTK_BOX(vbox), scrollWin, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Information");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
table = gtk_table_new(5, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
add_table_row(table, 0,
0, 0.5, "Product Name:", 0, 0.5, product_name);
add_table_row(table, 1,
0, 0.5, "Serial Number:", 0, 0.5, serial_number);
add_table_row(table, 2,
0, 0.5, "Build Date:", 0, 0.5, build_date);
add_table_row(table, 3,
0, 0.5, "Product ID:", 0, 0.5, product_id);
add_table_row(table, 4,
0, 0.5, "Firmware version:", 0, 0.5, firmware_version);
add_table_row(table, 5,
0, 0.5, "Hardware version:", 0, 0.5, hardware_version);
g_free(product_name);
g_free(serial_number);
g_free(build_date);
g_free(product_id);
g_free(firmware_version);
g_free(hardware_version);
/* Query Canoas 2.0 specific details */
if ((NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE,
&high_perf_mode) == NvCtrlSuccess) &&
(NvCtrlGetStringAttribute(ctk_object->handle,
NV_CTRL_STRING_VCSC_PSU_INFO,
&psu_str) == NvCtrlSuccess)) {
GtkWidget *vbox_padding;
/* Show the additonal queried information */
/* Populate scrolling window with data */
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Thermal Information");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
table = gtk_table_new(3, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
label = gtk_label_new("Intake Temperature:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->intake_temp = label;
label = gtk_label_new("Exhaust Temperature:");
/* This is the current largest label. Get its size */
gtk_widget_size_request(label, &ctk_object->req);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->exhaust_temp = label;
label = gtk_label_new("Board Temperature:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->board_temp = label;
/* Populate table for PSU information */
psuEntry.psu_current = -1;
psuEntry.psu_power = -1;
psuEntry.psu_voltage = -1;
psuEntry.psu_state = -1;
if (psu_str) {
parse_token_value_pairs(psu_str, apply_psu_entry_token, &psuEntry);
}
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Power Supply Unit Information");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
table = gtk_table_new(4, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
label = gtk_label_new("PSU State:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_state = label;
label = gtk_label_new("PSU Current:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_current = label;
current_row = 2;
if (psuEntry.psu_power != -1) {
label = gtk_label_new("PSU Power:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_power = label;
current_row++;
}
if (psuEntry.psu_voltage != -1) {
label = gtk_label_new("PSU Voltage:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_voltage = label;
}
/* Create container for fan status table */
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Fan Status");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 5);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
ctk_object->fan_status_container = hbox;
/* Register a timer callback to update the dynamic information */
s = g_strdup_printf("VCS Monitor (VCS %d)",
NvCtrlGetTargetId(ctk_object->handle));
ctk_config_add_timer(ctk_object->ctk_config,
DEFAULT_UPDATE_VCS_INFO_TIME_INTERVAL,
s,
(GSourceFunc) update_vcs_info,
(gpointer) ctk_object);
g_free(s);
update_vcs_info(ctk_object);
}
gtk_widget_show_all(GTK_WIDGET(object));
return GTK_WIDGET(object);
}
void
gui_create_tasks_page (GtkWidget *vbox, GUI *appGUI) {
GtkWidget *vbox5, *vbox6;
GtkWidget *vbox7, *vbox11, *vbox12;
GtkWidget *label;
GtkWidget *hbox1;
GtkWidget *frame;
GtkWidget *table;
GtkWidget *alignment;
GtkWidget *ti_font_button;
GtkWidget *scrolledwindow;
GtkWidget *tasks_category_table;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gchar tmpbuf[BUFFER_SIZE];
GdkColor color;
appGUI->opt->tasks_vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), appGUI->opt->tasks_vbox, FALSE, FALSE, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Appearance"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
vbox5 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox5);
gtk_container_add (GTK_CONTAINER (alignment), vbox5);
table = gtk_table_new (3, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox5), table, FALSE, FALSE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 8);
hbox1 = gtk_hbox_new (FALSE, 8);
gtk_widget_show (hbox1);
gtk_table_attach (GTK_TABLE (table), hbox1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
appGUI->opt->due_today_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->due_today_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->due_today_color_picker), "color-set",
G_CALLBACK(due_today_color_changed_cb), appGUI);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->due_today_color_picker, _("Color of items that are due today"), NULL);
gdk_color_parse(config.due_today_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_today_color_picker), &color);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->opt->due_today_color_picker, FALSE, FALSE, 0);
appGUI->opt->due_7days_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->due_7days_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->due_7days_color_picker), "color-set",
G_CALLBACK(due_7days_color_changed_cb), appGUI);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->due_7days_color_picker, _("Color of items that are due in the next 7 days"), NULL);
gdk_color_parse(config.due_7days_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->due_7days_color_picker), &color);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->opt->due_7days_color_picker, FALSE, FALSE, 0);
appGUI->opt->past_due_color_picker = gtk_color_button_new ();
gtk_widget_show (appGUI->opt->past_due_color_picker);
g_signal_connect (G_OBJECT (appGUI->opt->past_due_color_picker), "color-set",
G_CALLBACK(past_due_color_changed_cb), appGUI);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, appGUI->opt->past_due_color_picker, _("Color of items that are past due"), NULL);
gdk_color_parse(config.past_due_color, &color);
gtk_color_button_set_color (GTK_COLOR_BUTTON (appGUI->opt->past_due_color_picker), &color);
gtk_box_pack_start (GTK_BOX (hbox1), appGUI->opt->past_due_color_picker, FALSE, FALSE, 0);
appGUI->opt->ti_font_entry = gtk_entry_new ();
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ti_font_entry, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ti_font_entry);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->ti_font_entry, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
if (config.default_stock_icons) {
ti_font_button = gui_stock_button (GTK_STOCK_SELECT_FONT, FALSE);
} else {
ti_font_button = gui_stock_button (OSMO_STOCK_BUTTON_SELECT_FONT, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(ti_font_button, GTK_CAN_FOCUS);
gtk_widget_show (ti_font_button);
g_signal_connect (G_OBJECT (ti_font_button), "clicked",
G_CALLBACK (ti_font_select_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), ti_font_button, 2, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
sprintf(tmpbuf, "%s:", _("Task info font"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
sprintf(tmpbuf, "%s:", _("Colors"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->opt->tasks_enable_rules_hint_checkbutton = gtk_check_button_new_with_mnemonic (_("Draw rows in alternating colors"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_enable_rules_hint_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_enable_rules_hint_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_enable_rules_hint_checkbutton), "toggled",
G_CALLBACK (tasks_enable_rules_hint_checkbutton_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_enable_rules_hint_checkbutton, 0, 3, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Visible columns"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
vbox12 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox12);
gtk_container_add (GTK_CONTAINER (alignment), vbox12);
table = gtk_table_new (1, 3, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox12), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
appGUI->opt->vc_due_date_checkbutton = gtk_check_button_new_with_mnemonic (_("Due date"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_due_date_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_due_date_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_due_date_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_due_date_checkbutton, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->vc_priority_checkbutton = gtk_check_button_new_with_mnemonic (_("Priority"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_priority_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_priority_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_priority_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_priority_checkbutton, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
appGUI->opt->vc_category_checkbutton = gtk_check_button_new_with_mnemonic (_("Category"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->vc_category_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->vc_category_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->vc_category_checkbutton), "toggled",
G_CALLBACK (visible_columns_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->vc_category_checkbutton, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Categories"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
vbox6 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox6);
gtk_container_add (GTK_CONTAINER (alignment), vbox6);
tasks_category_table = gtk_table_new (4, 3, FALSE);
gtk_widget_show (tasks_category_table);
gtk_box_pack_start (GTK_BOX (vbox6), tasks_category_table, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (tasks_category_table), 8);
gtk_table_set_row_spacings (GTK_TABLE (tasks_category_table), 8);
gtk_table_set_col_spacings (GTK_TABLE (tasks_category_table), 4);
appGUI->opt->tasks_category_entry = gtk_entry_new ();
gtk_widget_show (appGUI->opt->tasks_category_entry);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_entry, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_category_entry), "key_release_event",
G_CALLBACK (tasks_category_entry_key_release_cb), appGUI);
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_table_attach (GTK_TABLE (tasks_category_table), scrolledwindow, 0, 3, 0, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN);
appGUI->opt->tasks_category_store = gtk_list_store_new(1, G_TYPE_STRING);
appGUI->opt->tasks_category_treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->opt->tasks_category_store));
appGUI->opt->tasks_category_select = gtk_tree_view_get_selection(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview));
gtk_widget_show (appGUI->opt->tasks_category_treeview);
g_signal_connect(G_OBJECT(appGUI->opt->tasks_category_select), "changed",
G_CALLBACK(tasks_category_selected_cb), appGUI);
gtk_container_add (GTK_CONTAINER (scrolledwindow), appGUI->opt->tasks_category_treeview);
gtk_container_set_border_width (GTK_CONTAINER (appGUI->opt->tasks_category_treeview), 4);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (appGUI->opt->tasks_category_treeview), FALSE);
gtk_widget_set_size_request (appGUI->opt->tasks_category_treeview, -1, 80);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->opt->tasks_category_treeview), column);
if (config.default_stock_icons) {
appGUI->opt->tasks_category_add_button = gui_stock_button(GTK_STOCK_ADD, FALSE);
} else {
appGUI->opt->tasks_category_add_button = gui_stock_button(OSMO_STOCK_BUTTON_ADD, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_add_button, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_category_add_button);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_add_button, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect(appGUI->opt->tasks_category_add_button, "clicked",
G_CALLBACK(tasks_category_add_cb), appGUI);
gtk_widget_set_sensitive(appGUI->opt->tasks_category_add_button, FALSE);
if (config.default_stock_icons) {
appGUI->opt->tasks_category_remove_button = gui_stock_button(GTK_STOCK_REMOVE, FALSE);
} else {
appGUI->opt->tasks_category_remove_button = gui_stock_button(OSMO_STOCK_BUTTON_REMOVE, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->tasks_category_remove_button, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->tasks_category_remove_button);
gtk_table_attach (GTK_TABLE (tasks_category_table), appGUI->opt->tasks_category_remove_button, 2, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
g_signal_connect(appGUI->opt->tasks_category_remove_button, "clicked",
G_CALLBACK(tasks_category_remove_cb), appGUI);
gtk_widget_set_sensitive(appGUI->opt->tasks_category_remove_button, FALSE);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Sorting"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
vbox7 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox7);
gtk_container_add (GTK_CONTAINER (alignment), vbox7);
table = gtk_table_new (1, 5, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox7), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
sprintf(tmpbuf, "%s:", _("Order"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
sprintf(tmpbuf, "%s:", _("Mode"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 2, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
appGUI->opt->tasks_sort_order_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->opt->tasks_sort_order_combobox);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_order_combobox), "changed",
G_CALLBACK(tasks_sort_order_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_order_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Ascending"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_order_combobox), _("Descending"));
gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_order_combobox), config.tasks_sorting_order);
appGUI->opt->tasks_sort_mode_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->opt->tasks_sort_mode_combobox);
g_signal_connect (G_OBJECT (appGUI->opt->tasks_sort_mode_combobox), "changed",
G_CALLBACK(tasks_sort_mode_changed_cb), appGUI);
gtk_table_attach (GTK_TABLE (table), appGUI->opt->tasks_sort_mode_combobox, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 0);
sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Due date"), _("Priority"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Done"), _("Priority"), _("Due date"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Due date"), _("Done"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Priority"), _("Done"), _("Due date"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Priority"), _("Done"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
sprintf (tmpbuf, "%s, %s, %s", _("Due date"), _("Done"), _("Priority"));
gtk_combo_box_append_text (GTK_COMBO_BOX (appGUI->opt->tasks_sort_mode_combobox), tmpbuf);
gtk_combo_box_set_active (GTK_COMBO_BOX(appGUI->opt->tasks_sort_mode_combobox), config.tasks_sorting_mode);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_box_pack_start (GTK_BOX (appGUI->opt->tasks_vbox), frame, FALSE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
sprintf(tmpbuf, "<b>%s</b>", _("Tasks options"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_frame_set_label_widget (GTK_FRAME (frame), label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_padding (GTK_MISC (label), 0, 4);
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment);
gtk_container_add (GTK_CONTAINER (frame), alignment);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 12, 12, 0);
vbox11 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox11);
gtk_container_add (GTK_CONTAINER (alignment), vbox11);
appGUI->opt->ct_hide_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Hide completed tasks"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_hide_items_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_hide_items_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled",
G_CALLBACK (hide_delete_changed_cb), appGUI);
gtk_box_pack_start (GTK_BOX (vbox11), appGUI->opt->ct_hide_items_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_hide_items_checkbutton), "toggled",
G_CALLBACK (hide_items_cb), appGUI);
appGUI->opt->ct_delete_items_checkbutton = gtk_check_button_new_with_mnemonic (_("Delete completed tasks without confirmation"));
GTK_WIDGET_UNSET_FLAGS(appGUI->opt->ct_delete_items_checkbutton, GTK_CAN_FOCUS);
gtk_widget_show (appGUI->opt->ct_delete_items_checkbutton);
g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled",
G_CALLBACK (hide_delete_changed_cb), appGUI);
gtk_box_pack_start (GTK_BOX (vbox11), appGUI->opt->ct_delete_items_checkbutton, FALSE, FALSE, 4);
g_signal_connect (G_OBJECT (appGUI->opt->ct_delete_items_checkbutton), "toggled",
G_CALLBACK (delete_items_cb), appGUI);
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox1;
GtkWidget *frame1;
GtkWidget *table1;
GtkWidget *buttonSelect;
GtkWidget *labelVobsub;
GtkWidget *label4;
GtkWidget *optionmenu1;
GtkWidget *label2;
GtkWidget *frame2;
GtkWidget *table2;
GtkWidget *label6;
GtkObject *spinbutton1_adj;
GtkWidget *spinbutton1;
GtkWidget *label7;
GtkWidget *entryShift;
GtkWidget *label5;
GtkWidget *dialog_action_area1;
GtkWidget *cancelbutton1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("VobSub Settings"));
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox1, TRUE, TRUE, 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox1), frame1, TRUE, TRUE, 0);
table1 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (frame1), table1);
buttonSelect = gtk_button_new_with_mnemonic (QT_TR_NOOP("Select .idx"));
gtk_widget_show (buttonSelect);
gtk_table_attach (GTK_TABLE (table1), buttonSelect, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
labelVobsub = gtk_label_new (QT_TR_NOOP("None"));
gtk_widget_show (labelVobsub);
gtk_table_attach (GTK_TABLE (table1), labelVobsub, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_justify (GTK_LABEL (labelVobsub), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment (GTK_MISC (labelVobsub), 0, 0.5);
label4 = gtk_label_new (QT_TR_NOOP("Select Language :"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), 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);
optionmenu1 = gtk_option_menu_new ();
gtk_widget_show (optionmenu1);
gtk_table_attach (GTK_TABLE (table1), optionmenu1, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label2 = gtk_label_new (QT_TR_NOOP("Select Sub"));
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label2);
gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (vbox1), frame2, TRUE, TRUE, 0);
table2 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (frame2), table2);
label6 = gtk_label_new (QT_TR_NOOP("Extra Shrink Factor :"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table2), 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);
spinbutton1_adj = gtk_adjustment_new (1, 1, 2, 0.1, 0.2, 0.2);
spinbutton1 = gtk_spin_button_new (GTK_ADJUSTMENT (spinbutton1_adj), 1, 0);
gtk_widget_show (spinbutton1);
gtk_table_attach (GTK_TABLE (table2), spinbutton1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label7 = gtk_label_new (QT_TR_NOOP("Shift (ms) :"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table2), label7, 0, 1, 1, 2,
(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);
entryShift = gtk_entry_new ();
gtk_widget_show (entryShift);
gtk_table_attach (GTK_TABLE (table2), entryShift, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
label5 = gtk_label_new (QT_TR_NOOP("Extra Settings"));
gtk_widget_show (label5);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label5);
gtk_label_set_justify (GTK_LABEL (label5), GTK_JUSTIFY_LEFT);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_show (cancelbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT (dialog1, buttonSelect, "buttonSelect");
GLADE_HOOKUP_OBJECT (dialog1, labelVobsub, "labelVobsub");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT (dialog1, optionmenu1, "optionmenu1");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2");
GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, spinbutton1, "spinbutton1");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, entryShift, "entryShift");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
return dialog1;
}
static gboolean update_fan_status(CtkVcs *ctk_object)
{
gint ret;
char *fan_entry_str = NULL;
char *tokens;
GtkWidget *table;
GtkWidget *label;
FanEntry current_fan;
gchar output_str[16];
gint current_row;
if (!ctk_object->fan_status_container) {
return FALSE;
}
ret = NvCtrlGetStringAttribute(ctk_object->handle,
NV_CTRL_STRING_VCSC_FAN_STATUS,
&fan_entry_str);
if (ret != NvCtrlSuccess) {
return FALSE;
}
ctk_empty_container(ctk_object->fan_status_container);
/* Generate the new table */
table = gtk_table_new(1, 3, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
gtk_box_pack_start(GTK_BOX(ctk_object->fan_status_container),
table, FALSE, FALSE, 0);
label = gtk_label_new("Fan Number");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Fan Speed");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Fan Status");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 2, 3, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
/* Parse string of fan entries and populate table */
current_row = 1;
for (tokens = strtok(fan_entry_str, ";");
tokens;
tokens = strtok(NULL, ";")) {
/* Invalidate fan entry */
current_fan.fan_number = -1;
current_fan.fan_speed = -1;
current_fan.fan_failed = -1;
parse_token_value_pairs(tokens, apply_fan_entry_token, ¤t_fan);
if ((current_fan.fan_number != -1) &&
(current_fan.fan_speed != -1) &&
(current_fan.fan_failed != -1)) {
gtk_table_resize(GTK_TABLE(table), current_row + 1, 3);
g_snprintf(output_str, 16, "%d", current_fan.fan_number);
label = gtk_label_new(output_str);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, current_row,
current_row + 1, GTK_FILL,
GTK_FILL | GTK_EXPAND, 5, 0);
g_snprintf(output_str, 16, "%d rpm", current_fan.fan_speed);
label = gtk_label_new(output_str);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, current_row,
current_row + 1, GTK_FILL,
GTK_FILL | GTK_EXPAND, 5, 0);
if (!current_fan.fan_failed) {
g_snprintf(output_str, 16, "Ok");
} else {
g_snprintf(output_str, 16, "Failed");
}
label = gtk_label_new(output_str);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 2, 3, current_row,
current_row + 1, GTK_FILL,
GTK_FILL | GTK_EXPAND, 5, 0);
current_row++;
} else {
nv_warning_msg("Incomplete Fan Entry (fan=%d, speed=%d, failFlag=%d)",
current_fan.fan_number,
current_fan.fan_speed,
current_fan.fan_failed);
}
}
gtk_widget_show_all(table);
XFree(fan_entry_str);
return TRUE;
}
static GtkWidget *create_window(void)
{
stwidgets.accel_group = gtk_accel_group_new();
// Basic window
stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title
gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
// Horizontal layout of banner and controls
stwidgets.hlayout = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout);
// banner
{
GdkPixbuf *pixbuf = load_banner();
stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref((gpointer)pixbuf);
}
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0);
// Vertical layout of tab control and start+cancel buttons
stwidgets.vlayout = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0);
// Tab control
stwidgets.tabs = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4);
// layout table of config page
stwidgets.configtlayout = gtk_table_new(4, 3, FALSE);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout);
// 2D video mode label
stwidgets.vmode2dlabel = gtk_label_new_with_mnemonic("_2D Video mode:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode2dlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode2dlabel, 0,1, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 6);
// 2D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
stwidgets.vmode2dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode2dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode2dcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode2dcombo, 1,2, 0,1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 6);
gtk_widget_add_accelerator(stwidgets.vmode2dcombo, "grab_focus", stwidgets.accel_group,
GDK_2, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Fullscreen checkbox
stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.fullscreencheck, 2,3, 0,1, GTK_FILL, (GtkAttachOptions)0, 4, 6);
gtk_widget_add_accelerator(stwidgets.fullscreencheck, "grab_focus", stwidgets.accel_group,
GDK_F, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// 3D video mode label
stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_3D Video mode:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 1,2, GTK_FILL, (GtkAttachOptions)0, 4, 6);
// 3D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 1,2,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)0, 4, 0);
gtk_widget_add_accelerator(stwidgets.vmode3dcombo, "grab_focus", stwidgets.accel_group,
GDK_3, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Empty horizontal layout
stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,1, 2,3, (GtkAttachOptions)0,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0);
// Always show config checkbox
stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show configuration on start");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,2, 3,4, GTK_FILL, (GtkAttachOptions)0, 4, 6);
gtk_widget_add_accelerator(stwidgets.alwaysshowcheck, "grab_focus", stwidgets.accel_group,
GDK_A, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
// Configuration tab
stwidgets.configtab = gtk_label_new("Configuration");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab);
// Messages scrollable area
stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// Messages text area
stwidgets.messagestext = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext);
gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
// Messages tab
stwidgets.messagestab = gtk_label_new("Messages");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.messagestab);
// Dialogue box buttons layout
stwidgets.buttons = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3);
gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END);
// Cancel button
stwidgets.cancelbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator(stwidgets.cancelbutton, "grab_focus", stwidgets.accel_group,
GDK_C, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(stwidgets.cancelbutton, "clicked", stwidgets.accel_group,
GDK_Escape, (GdkModifierType)0,
GTK_ACCEL_VISIBLE);
stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign);
stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout);
stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0);
stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel");
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0);
// Start button
stwidgets.startbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT);
gtk_widget_add_accelerator(stwidgets.startbutton, "grab_focus", stwidgets.accel_group,
GDK_S, GDK_MOD1_MASK,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(stwidgets.startbutton, "clicked", stwidgets.accel_group,
GDK_Return, (GdkModifierType)0,
GTK_ACCEL_VISIBLE);
stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign);
stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout);
stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0);
stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start");
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0);
// Wire up the signals
g_signal_connect((gpointer) stwidgets.startwin, "delete_event",
G_CALLBACK(on_startwin_delete_event),
NULL);
g_signal_connect((gpointer) stwidgets.vmode2dcombo, "changed",
G_CALLBACK(on_vmode2dcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed",
G_CALLBACK(on_vmode3dcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled",
G_CALLBACK(on_fullscreencheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled",
G_CALLBACK(on_alwaysshowcheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked",
G_CALLBACK(on_cancelbutton_clicked),
NULL);
g_signal_connect((gpointer) stwidgets.startbutton, "clicked",
G_CALLBACK(on_startbutton_clicked),
NULL);
// Associate labels with their controls
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode2dlabel), stwidgets.vmode2dcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo);
gtk_window_add_accel_group(GTK_WINDOW(stwidgets.startwin), stwidgets.accel_group);
return stwidgets.startwin;
}
void gui_init(dt_iop_module_t *self)
{
self->widget = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(self->widget), 0.0, 0.5);
}
static GimpPDBStatusType
lcms_dialog (GimpColorConfig *config,
gint32 image,
gboolean apply,
LcmsValues *values)
{
GimpColorProfileComboBox *box;
GtkWidget *dialog;
GtkWidget *main_vbox;
GtkWidget *frame;
GtkWidget *label;
GtkWidget *combo;
cmsHPROFILE src_profile;
gchar *name;
gboolean success = FALSE;
gboolean run;
GError *error = NULL;
src_profile = lcms_image_get_profile (config, image, &error);
if (error)
{
g_message ("%s", error->message);
g_clear_error (&error);
}
if (! src_profile)
src_profile = gimp_lcms_create_srgb_profile ();
gimp_ui_init (PLUG_IN_BINARY, FALSE);
dialog = gimp_dialog_new (apply ?
_("Convert to ICC Color Profile") :
_("Assign ICC Color Profile"),
PLUG_IN_ROLE,
NULL, 0,
gimp_standard_help_func,
apply ? PLUG_IN_PROC_APPLY : PLUG_IN_PROC_SET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
apply ? GTK_STOCK_CONVERT : _("_Assign"),
GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
gimp_window_set_transient (GTK_WINDOW (dialog));
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 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 (_("Current Color Profile"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
name = gimp_lcms_profile_get_label (src_profile);
label = gtk_label_new (name);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_widget_show (label);
g_free (name);
frame = gimp_frame_new (apply ? _("Convert to") : _("Assign"));
gtk_box_pack_start (GTK_BOX (main_vbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
combo = lcms_icc_combo_box_new (config, NULL);
gtk_container_add (GTK_CONTAINER (frame), combo);
gtk_widget_show (combo);
box = GIMP_COLOR_PROFILE_COMBO_BOX (combo);
if (apply)
{
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *toggle;
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (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),
values->intent,
G_CALLBACK (gimp_int_combo_box_get_active),
&values->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), values->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),
&values->bpc);
}
while ((run = gimp_dialog_run (GIMP_DIALOG (dialog))) == GTK_RESPONSE_OK)
{
gchar *filename = gimp_color_profile_combo_box_get_active (box);
cmsHPROFILE dest_profile;
gtk_widget_set_sensitive (dialog, FALSE);
if (filename)
{
GError *error = NULL;
dest_profile = gimp_lcms_profile_open_from_file (filename, &error);
if (! dest_profile)
{
g_message ("%s", error->message);
g_clear_error (&error);
}
}
else
{
dest_profile = gimp_lcms_create_srgb_profile ();
}
if (dest_profile)
{
if (gimp_lcms_profile_is_rgb (dest_profile))
{
if (apply)
success = lcms_image_apply_profile (image,
src_profile, dest_profile,
filename,
values->intent,
values->bpc);
else
success = lcms_image_set_profile (image,
dest_profile, filename);
}
else
{
gimp_message (_("Destination profile is not for RGB color space."));
}
cmsCloseProfile (dest_profile);
}
if (success)
break;
else
gtk_widget_set_sensitive (dialog, TRUE);
}
gtk_widget_destroy (dialog);
cmsCloseProfile (src_profile);
return (run ?
(success ? GIMP_PDB_SUCCESS : GIMP_PDB_EXECUTION_ERROR) :
GIMP_PDB_CANCEL);
}
static gboolean
confirm_delete_immediately (GtkWidget *parent_view,
gint num_files,
gboolean all)
{
GdkScreen *screen;
GtkWidget *dialog, *hbox, *vbox, *image, *label;
gchar *str, *prompt, *detail;
int response;
screen = gtk_widget_get_screen (parent_view);
dialog = gtk_dialog_new ();
gtk_window_set_screen (GTK_WINDOW (dialog), screen);
atk_object_set_role (gtk_widget_get_accessible (dialog), ATK_ROLE_ALERT);
gtk_window_set_title (GTK_WINDOW (dialog), _("Delete Immediately?"));
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_realize (dialog);
gdk_window_set_transient_for (gtk_widget_get_window (GTK_WIDGET (dialog)),
gdk_screen_get_root_window (screen));
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 14);
hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), hbox,
FALSE, FALSE, 0);
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_QUESTION,
GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_widget_show (image);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
vbox = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
if (all)
{
prompt = _("Cannot move items to trash, do you want to delete them immediately?");
detail = g_strdup_printf ("None of the %d selected items can be moved to the Trash", num_files);
}
else
{
prompt = _("Cannot move some items to trash, do you want to delete these immediately?");
detail = g_strdup_printf ("%d of the selected items cannot be moved to the Trash", num_files);
}
str = g_strconcat ("<span weight=\"bold\" size=\"larger\">",
prompt, "</span>", NULL);
label = gtk_label_new (str);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (str);
label = gtk_label_new (detail);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
g_free (detail);
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_DELETE,
GTK_RESPONSE_YES);
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_YES);
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (GTK_WIDGET (dialog));
return response == GTK_RESPONSE_YES;
}
int I_PickIWad_Gtk (WadStuff *wads, int numwads, bool showwin, int defaultiwad)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *bbox;
GtkWidget *widget;
GtkWidget *tree;
GtkWidget *check;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
GtkTreeIter iter, defiter;
int close_style = 0;
int i;
char caption[100];
// Create the dialog window.
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
mysnprintf(caption, countof(caption), GAMESIG " %s: Select an IWAD to use", GetVersionString());
gtk_window_set_title (GTK_WINDOW(window), caption);
gtk_window_set_position (GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width (GTK_CONTAINER(window), 10);
g_signal_connect (window, "delete_event", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect (window, "key_press_event", G_CALLBACK(CheckEscape), NULL);
// Create the vbox container.
vbox = gtk_vbox_new (FALSE, 10);
gtk_container_add (GTK_CONTAINER(window), vbox);
// Create the top label.
widget = gtk_label_new ("ZDoom found more than one IWAD\nSelect from the list below to determine which one to use:");
gtk_box_pack_start (GTK_BOX(vbox), widget, false, false, 0);
gtk_misc_set_alignment (GTK_MISC(widget), 0, 0);
// Create a list store with all the found IWADs.
store = gtk_list_store_new (3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
for (i = 0; i < numwads; ++i)
{
const char *filepart = strrchr (wads[i].Path, '/');
if (filepart == NULL)
filepart = wads[i].Path;
else
filepart++;
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, filepart,
1, wads[i].Name.GetChars(),
2, i,
-1);
if (i == defaultiwad)
{
defiter = iter;
}
}
// Create the tree view control to show the list.
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store));
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("IWAD", renderer, "text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Game", renderer, "text", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(tree), column);
gtk_box_pack_start (GTK_BOX(vbox), GTK_WIDGET(tree), true, true, 0);
g_signal_connect(G_OBJECT(tree), "button_press_event", G_CALLBACK(DoubleClickChecker), &close_style);
g_signal_connect(G_OBJECT(tree), "key_press_event", G_CALLBACK(AllowDefault), window);
// Select the default IWAD.
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(tree));
gtk_tree_selection_select_iter (selection, &defiter);
// Create the hbox for the bottom row.
hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_end (GTK_BOX(vbox), hbox, false, false, 0);
// Create the "Don't ask" checkbox.
check = gtk_check_button_new_with_label ("Don't ask me this again");
gtk_box_pack_start (GTK_BOX(hbox), check, false, false, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check), !showwin);
// Create the OK/Cancel button box.
bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout (GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX(bbox), 10);
gtk_box_pack_end (GTK_BOX(hbox), bbox, false, false, 0);
// Create the OK button.
widget = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0);
GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
gtk_widget_grab_default (widget);
g_signal_connect (widget, "clicked", G_CALLBACK(ClickedOK), &close_style);
g_signal_connect (widget, "activate", G_CALLBACK(ClickedOK), &close_style);
// Create the cancel button.
widget = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
gtk_box_pack_start (GTK_BOX(bbox), widget, false, false, 0);
g_signal_connect (widget, "clicked", G_CALLBACK(gtk_main_quit), &window);
// Finally we can show everything.
gtk_widget_show_all (window);
gtk_main ();
if (close_style == 1)
{
GtkTreeModel *model;
GValue value = { 0, { {0} } };
// Find out which IWAD was selected.
gtk_tree_selection_get_selected (selection, &model, &iter);
gtk_tree_model_get_value (GTK_TREE_MODEL(model), &iter, 2, &value);
i = g_value_get_int (&value);
g_value_unset (&value);
// Set state of queryiwad based on the checkbox.
queryiwad = !gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check));
}
else
{
i = -1;
}
if (GTK_IS_WINDOW(window))
{
gtk_widget_destroy (window);
// If we don't do this, then the X window might not actually disappear.
while (g_main_context_iteration (NULL, FALSE)) {}
}
return i;
}
GtkWidget *create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *table1;
GtkWidget *label1;
GtkWidget *label3;
GtkWidget *label5;
GtkWidget *label_19;
GtkWidget *label_label;
GtkWidget *label_labelfps;
GtkWidget *dialog_action_area1;
dialog1 = gtk_dialog_new ();
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog1", dialog1);
gtk_window_set_title (GTK_WINDOW (dialog1), "Encoding");
gtk_window_set_policy (GTK_WINDOW (dialog1), TRUE, TRUE, FALSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_vbox1", dialog_vbox1);
gtk_widget_show (dialog_vbox1);
gtk_window_set_modal(GTK_WINDOW(dialog1), 1);
table1 = gtk_table_new (4, 2, FALSE);
gtk_widget_ref (table1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "table1", table1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), table1, TRUE, TRUE, 0);
label1 = gtk_label_new (" Phasis :");
gtk_widget_ref (label1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label1", label1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label1);
gtk_table_attach (GTK_TABLE (table1), label1, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND), 0, 0);
gtk_label_set_line_wrap (GTK_LABEL (label1), TRUE);
gtk_misc_set_alignment (GTK_MISC (label1), 0, 0.5);
label_phasis = gtk_label_new ("Idling");
gtk_widget_ref (label_phasis);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_phasis", label_phasis,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_phasis);
gtk_table_attach (GTK_TABLE (table1), label_phasis, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_phasis), 0, 0.5);
label3 = gtk_label_new (" Frame # :");
gtk_widget_ref (label3);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label3", label3,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label_frame = gtk_label_new ("0");
gtk_widget_ref (label_frame);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_frame", label_frame,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_frame);
gtk_table_attach (GTK_TABLE (table1), label_frame, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_frame), 0, 0.5);
label5 = gtk_label_new (" Estimated time left :");
gtk_widget_ref (label5);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label5", label5,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label_eta = gtk_label_new ("0");
gtk_widget_ref (label_eta);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_eta", label_eta,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_eta);
gtk_table_attach (GTK_TABLE (table1), label_eta, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_eta), 0, 0.5);
label_19 = gtk_label_new (" Codec used :");
gtk_widget_ref (label_19);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_19", label_19,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_19);
gtk_table_attach (GTK_TABLE (table1), label_19, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_19), 0, 0.5);
//--
label_codec = gtk_label_new ("None");
gtk_widget_ref (label_codec);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_codec", label_codec,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_codec);
gtk_table_attach (GTK_TABLE (table1), label_codec, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_codec), 0, 0.5);
// fps
label_labelfps = gtk_label_new (" Fps");
gtk_widget_ref (label_labelfps);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_labelfps", label_labelfps,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_labelfps);
gtk_table_attach (GTK_TABLE (table1), label_labelfps, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_labelfps), 0, 0.5);
label_fps = gtk_label_new ("0");
gtk_widget_ref (label_fps);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_fps", label_fps,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_fps);
gtk_table_attach (GTK_TABLE (table1), label_fps, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_fps), 0, 0.5);
// size label_label
label_label = gtk_label_new (" Size MB");
gtk_widget_ref (label_label);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_label", label_label,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_label);
gtk_table_attach (GTK_TABLE (table1), label_label, 0, 1, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_label), 0, 0.5);
label_size = gtk_label_new ("None");
gtk_widget_ref (label_size);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "label_size", label_size,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (label_size);
gtk_table_attach (GTK_TABLE (table1), label_size, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_size), 0, 0.5);
//
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_action_area1", dialog_action_area1);
gtk_widget_show (dialog_action_area1);
// progress bar
//________________
progressbar1 = gtk_progress_bar_new ();
gtk_widget_ref (progressbar1);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "progressbar1", progressbar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (progressbar1);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), progressbar1, FALSE, FALSE, 0);
// / progress bar
gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10);
//
button_cancel = gtk_button_new_with_label ("Abort");
gtk_widget_ref (button_cancel);
gtk_object_set_data_full (GTK_OBJECT (dialog1), "button_cancel", button_cancel,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (button_cancel);
gtk_box_pack_start (GTK_BOX (dialog_action_area1), button_cancel, FALSE, FALSE, 0);
// Call back
gtk_object_set_data_full(GTK_OBJECT(dialog1),
"dialog1", dialog1,
(GtkDestroyNotify) cb_destroy);
gtk_signal_connect(GTK_OBJECT(button_cancel),
"button_press_event", GTK_SIGNAL_FUNC(cb_abort),
0);
return dialog1;
}
GtkWidget*
create_aboutlshw (void)
{
GtkWidget *aboutlshw;
GtkWidget *dialog_vbox1;
GtkWidget *aboutext;
GtkWidget *version;
GtkWidget *dialog_action_area1;
GtkWidget *closebutton1;
aboutlshw = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (aboutlshw), "About");
gtk_window_set_position (GTK_WINDOW (aboutlshw), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_resizable (GTK_WINDOW (aboutlshw), FALSE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (aboutlshw), TRUE);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (aboutlshw), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (aboutlshw), TRUE);
gtk_window_set_type_hint (GTK_WINDOW (aboutlshw), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (aboutlshw)->vbox;
gtk_widget_show (dialog_vbox1);
aboutext = gtk_label_new ("<big><b>GTK+ front-end for <tt>lshw</tt></b></big>\n\n\302\251 2004-2009 Lyonel Vincent\n<tt>[email protected]</tt>\n\n<span foreground=\"blue\"><u>http://www.ezix.org/</u></span>");
gtk_widget_show (aboutext);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), aboutext, FALSE, FALSE, 0);
gtk_label_set_use_markup (GTK_LABEL (aboutext), TRUE);
gtk_label_set_justify (GTK_LABEL (aboutext), GTK_JUSTIFY_CENTER);
gtk_misc_set_padding (GTK_MISC (aboutext), 20, 20);
version = gtk_label_new ("VERSION");
gtk_widget_show (version);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), version, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (version), GTK_JUSTIFY_CENTER);
dialog_action_area1 = GTK_DIALOG (aboutlshw)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
closebutton1 = gtk_button_new_from_stock ("gtk-close");
gtk_widget_show (closebutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (aboutlshw), closebutton1, GTK_RESPONSE_CLOSE);
GTK_WIDGET_SET_FLAGS (closebutton1, GTK_CAN_DEFAULT);
g_signal_connect ((gpointer) version, "realize",
G_CALLBACK (on_version_realize),
NULL);
g_signal_connect ((gpointer) closebutton1, "activate",
G_CALLBACK (on_aboutclose_activate),
NULL);
g_signal_connect ((gpointer) closebutton1, "clicked",
G_CALLBACK (on_aboutclose_activate),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (aboutlshw, aboutlshw, "aboutlshw");
GLADE_HOOKUP_OBJECT_NO_REF (aboutlshw, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (aboutlshw, aboutext, "aboutext");
GLADE_HOOKUP_OBJECT (aboutlshw, version, "version");
GLADE_HOOKUP_OBJECT_NO_REF (aboutlshw, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (aboutlshw, closebutton1, "closebutton1");
return aboutlshw;
}
static GtkWidget* _lib_import_get_extra_widget(dt_lib_import_metadata_t *data, gboolean import_folder)
{
// add extra lines to 'extra'. don't forget to destroy the widgets later.
GtkWidget *expander = gtk_expander_new(_("import options"));
gtk_expander_set_expanded(GTK_EXPANDER(expander), dt_conf_get_bool("ui_last/import_options_expanded"));
GtkWidget *frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame),GTK_SHADOW_IN);
GtkWidget *alignment = gtk_alignment_new(1.0, 1.0, 1.0, 1.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 8, 8, 8, 8);
GtkWidget *event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(frame), event_box);
gtk_container_add(GTK_CONTAINER(event_box), alignment);
gtk_container_add(GTK_CONTAINER(alignment), expander);
GtkWidget *extra;
extra = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(expander), extra);
GtkWidget *recursive = NULL, *ignore_jpeg = NULL;
if(import_folder == TRUE)
{
// recursive opening.
recursive = gtk_check_button_new_with_label (_("import directories recursively"));
g_object_set(recursive, "tooltip-text", _("recursively import subdirectories. each directory goes into a new film roll."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (recursive), dt_conf_get_bool("ui_last/import_recursive"));
gtk_box_pack_start(GTK_BOX (extra), recursive, FALSE, FALSE, 0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files"));
g_object_set(ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+JPEG in a directory."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_box_pack_start(GTK_BOX (extra), ignore_jpeg, FALSE, FALSE, 0);
}
// default metadata
GtkWidget *apply_metadata;
GtkWidget *table, *label, *creator, *publisher, *rights, *tags;
apply_metadata = gtk_check_button_new_with_label (_("apply metadata on import"));
g_object_set(apply_metadata, "tooltip-text", _("apply some metadata to all newly imported images."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (apply_metadata), dt_conf_get_bool("ui_last/import_apply_metadata"));
gtk_box_pack_start(GTK_BOX (extra), apply_metadata, FALSE, FALSE, 0);
GValue value = {0, };
g_value_init(&value, G_TYPE_INT);
gtk_widget_style_get_property(apply_metadata, "indicator-size", &value);
gint indicator_size = g_value_get_int(&value);
// gtk_widget_style_get_property(apply_metadata, "indicator-spacing", &value);
// gint indicator_spacing = g_value_get_int(&value);
table = gtk_table_new(6, 3, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 5);
alignment = gtk_alignment_new(0, 0, 1, 1);
gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 2*indicator_size, 0);
gtk_container_add(GTK_CONTAINER(alignment), table);
gtk_box_pack_start(GTK_BOX (extra), alignment, FALSE, FALSE, 0);
creator = gtk_entry_new();
gtk_widget_set_size_request(creator, 300, -1);
gtk_entry_set_text(GTK_ENTRY(creator), dt_conf_get_string("ui_last/import_last_creator"));
publisher = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(publisher), dt_conf_get_string("ui_last/import_last_publisher"));
rights = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(rights), dt_conf_get_string("ui_last/import_last_rights"));
tags = gtk_entry_new();
g_object_set(tags, "tooltip-text", _("comma separated list of tags"), NULL);
gtk_entry_set_text(GTK_ENTRY(tags), dt_conf_get_string("ui_last/import_last_tags"));
// presets from the metadata plugin
GtkCellRenderer *renderer;
GtkTreeIter iter;
GtkListStore *model = gtk_list_store_new(N_COLUMNS,
G_TYPE_STRING /*name*/,
G_TYPE_STRING /*creator*/,
G_TYPE_STRING /*publisher*/,
G_TYPE_STRING /*rights*/);
GtkWidget *presets = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(presets), renderer, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(presets), renderer, "text", NAME_COLUMN, NULL);
sqlite3_stmt *stmt;
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db), "select name, op_params from presets where operation = \"metadata\"", -1, &stmt, NULL);
while(sqlite3_step(stmt) == SQLITE_ROW)
{
void *op_params = (void *)sqlite3_column_blob(stmt, 1);
int32_t op_params_size = sqlite3_column_bytes(stmt, 1);
char *buf = (char* )op_params;
char *title = buf;
buf += strlen(title) + 1;
char *description = buf;
buf += strlen(description) + 1;
char *rights = buf;
buf += strlen(rights) + 1;
char *creator = buf;
buf += strlen(creator) + 1;
char *publisher = buf;
if(op_params_size == strlen(title) + strlen(description) + strlen(rights) + strlen(creator) + strlen(publisher) + 5)
{
gtk_list_store_append(model, &iter);
gtk_list_store_set (model, &iter,
NAME_COLUMN, (char *)sqlite3_column_text(stmt, 0),
CREATOR_COLUMN, creator,
PUBLISHER_COLUMN, publisher,
RIGHTS_COLUMN, rights,
-1);
}
}
sqlite3_finalize(stmt);
g_object_unref(model);
int line = 0;
label = gtk_label_new(_("preset"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), presets, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
line++;
label = gtk_label_new(_("creator"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), creator, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
line++;
label = gtk_label_new(_("publisher"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), publisher, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
line++;
label = gtk_label_new(_("rights"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), rights, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
line++;
label = gtk_label_new(_("tags"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, line, line+1, GTK_FILL, 0, 0, 0);
gtk_table_attach(GTK_TABLE(table), tags, 1, 2, line, line+1, GTK_FILL, 0, 0, 0);
gtk_widget_show_all(frame);
if(data != NULL)
{
data->frame = frame;
data->recursive = recursive;
data->ignore_jpeg = ignore_jpeg;
data->expander = expander;
data->apply_metadata = apply_metadata;
data->presets = presets;
data->creator = creator;
data->publisher = publisher;
data->rights = rights;
data->tags = tags;
}
g_signal_connect(apply_metadata, "toggled", G_CALLBACK (_lib_import_apply_metadata_toggled), table);
_lib_import_apply_metadata_toggled(apply_metadata, table); // needed since the apply_metadata starts being turned off,
// and setting it to off doesn't emit the 'toggled' signal ...
g_signal_connect(presets, "changed", G_CALLBACK(_lib_import_presets_changed), data);
g_signal_connect(GTK_ENTRY(creator), "changed", G_CALLBACK (_lib_import_metadata_changed), presets);
g_signal_connect(GTK_ENTRY(publisher), "changed", G_CALLBACK (_lib_import_metadata_changed), presets);
g_signal_connect(GTK_ENTRY(rights), "changed", G_CALLBACK (_lib_import_metadata_changed), presets);
return frame;
}
GtkWidget *
x264_gtk_encode_status_window (X264_Thread_Data *thread_data)
{
GtkWidget *win_status;
GtkWidget *table;
GtkWidget *label;
if (!thread_data) return NULL;
win_status = thread_data->dialog = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (win_status), _("Encoding status"));
thread_data->button = gtk_dialog_add_button (GTK_DIALOG (win_status),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
thread_data->end_button = gtk_dialog_add_button (GTK_DIALOG (thread_data->dialog),
GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL);
gtk_widget_set_sensitive (thread_data->end_button, FALSE);
g_signal_connect (G_OBJECT (win_status),
"delete-event",
G_CALLBACK (_delete_window_cb),
thread_data);
g_signal_connect (G_OBJECT (win_status),
"response",
G_CALLBACK (_response_window_cb),
thread_data);
table = gtk_table_new (5, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (win_status)->vbox), table,
FALSE, FALSE, 0);
gtk_widget_show (table);
label = gtk_label_new (_("Current video frame:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 0, 1);
gtk_widget_show (label);
thread_data->current_video_frame = gtk_entry_new ();
gtk_editable_set_editable (GTK_EDITABLE (thread_data->current_video_frame), FALSE);
gtk_table_attach_defaults (GTK_TABLE (table),
thread_data->current_video_frame,
1, 2, 0, 1);
gtk_widget_show (thread_data->current_video_frame);
label = gtk_label_new (_("Video data:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 1, 2);
gtk_widget_show (label);
thread_data->video_data = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (thread_data->video_data), _("0KB"));
gtk_editable_set_editable (GTK_EDITABLE (thread_data->video_data), FALSE);
gtk_table_attach_defaults (GTK_TABLE (table), thread_data->video_data,
1, 2, 1, 2);
gtk_widget_show (thread_data->video_data);
label = gtk_label_new (_("Video rendering rate:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 2, 3);
gtk_widget_show (label);
thread_data->video_rendering_rate = gtk_entry_new ();
gtk_editable_set_editable (GTK_EDITABLE (thread_data->video_rendering_rate), FALSE);
gtk_table_attach_defaults (GTK_TABLE (table),
thread_data->video_rendering_rate,
1, 2, 2, 3);
gtk_widget_show (thread_data->video_rendering_rate);
label = gtk_label_new (_("Time elapsed:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 3, 4);
gtk_widget_show (label);
thread_data->time_elapsed = gtk_entry_new ();
gtk_editable_set_editable (GTK_EDITABLE (thread_data->time_elapsed), FALSE);
gtk_table_attach_defaults (GTK_TABLE (table), thread_data->time_elapsed,
1, 2, 3, 4);
gtk_widget_show (thread_data->time_elapsed);
label = gtk_label_new (_("Time remaining (estimated):"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table), label, 0, 1, 4, 5);
gtk_widget_show (label);
thread_data->time_remaining = gtk_entry_new ();
gtk_editable_set_editable (GTK_EDITABLE (thread_data->time_remaining), FALSE);
gtk_table_attach_defaults (GTK_TABLE (table), thread_data->time_remaining,
1, 2, 4, 5);
gtk_widget_show (thread_data->time_remaining);
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (win_status)->vbox), table,
FALSE, FALSE, 0);
gtk_widget_show (table);
label = gtk_label_new (_("Progress:"));
gtk_misc_set_alignment (GTK_MISC (label),
0.0, 0.5);
gtk_table_attach_defaults (GTK_TABLE (table),
label,
0, 1,
0, 1);
gtk_widget_show (label);
thread_data->progress = gtk_progress_bar_new ();
gtk_table_attach_defaults (GTK_TABLE (table), thread_data->progress,
1, 2, 0, 1);
gtk_widget_show (thread_data->progress);
return win_status;
}
void DownloadUI::CreateDownloadUI(void)
{
m_downloadUI = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(m_downloadUI), BRANDING" - DownloadManager");
gtk_signal_connect(GTK_OBJECT(m_downloadUI), "destroy",
GTK_SIGNAL_FUNC(toggle_vis_internal), this);
gtk_container_set_border_width(GTK_CONTAINER(m_downloadUI), 5);
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(m_downloadUI), vbox);
gtk_widget_set_usize(vbox, 400, 400);
gtk_widget_show(vbox);
GtkWidget *text = gtk_label_new(NULL);
gtk_label_set_line_wrap(GTK_LABEL(text), TRUE);
if (!strncasecmp(BRANDING_COMPANY, "EMusic", 6))
gtk_label_set_text(GTK_LABEL(text), szEMusicText);
else
gtk_label_set_text(GTK_LABEL(text), szFreeAmpText);
gtk_label_set_justify(GTK_LABEL(text), GTK_JUSTIFY_FILL);
gtk_misc_set_alignment(GTK_MISC(text), (gfloat)0.0, (gfloat)0.0);
gtk_box_pack_start(GTK_BOX(vbox), text, FALSE, FALSE, 2);
gtk_widget_set_usize(text, 400, 46);
gtk_widget_show(text);
GtkWidget *emusic_button;
if (!strncasecmp(BRANDING_COMPANY, "EMusic", 6))
emusic_button = gtk_button_new_with_label(szEMusicURLText);
else
emusic_button = gtk_button_new_with_label(szFreeAmpURLText);
gtk_box_pack_start(GTK_BOX(vbox), emusic_button, FALSE, FALSE, 2);
gtk_signal_connect(GTK_OBJECT(emusic_button), "clicked",
GTK_SIGNAL_FUNC(emusic_click), this);
gtk_widget_show(emusic_button);
GtkWidget *listwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(listwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), listwindow, TRUE, TRUE, 0);
gtk_widget_set_usize(listwindow, 400, 140);
gtk_widget_show(listwindow);
GtkWidget *table = gtk_table_new(7, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
gtk_widget_show(table);
GtkWidget *label = gtk_label_new("Artist:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
artist = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(artist), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), artist, 1, 2, 0, 1);
gtk_widget_show(artist);
label = gtk_label_new("Album:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
album = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(album), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), album, 1, 2, 1, 2);
gtk_widget_show(album);
label = gtk_label_new("Title:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
title = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(title), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), title, 1, 2, 2, 3);
gtk_widget_show(title);
label = gtk_label_new("Genre:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
genre = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(genre), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), genre, 1, 2, 3, 4);
gtk_widget_show(genre);
label = gtk_label_new("Playlist:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
playlist = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(playlist), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), playlist, 1, 2, 4, 5);
gtk_widget_show(playlist);
label = gtk_label_new("File Name:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 5, 6, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
name = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(name), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), name, 1, 2, 5, 6);
gtk_widget_show(name);
label = gtk_label_new("File Size:");
gtk_misc_set_alignment(GTK_MISC(label), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 6, 7, GTK_FILL, GTK_FILL,
10, 1);
gtk_widget_show(label);
size = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(size), (gfloat)0.0, (gfloat)0.5);
gtk_table_attach_defaults(GTK_TABLE(table), size, 1, 2, 6, 7);
gtk_widget_show(size);
CreateDownloadList(listwindow);
GtkWidget *sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, TRUE, 2);
gtk_widget_show(sep);
m_closeComplete = gtk_check_button_new_with_label("Close the Download Manager when all downloads finish");
gtk_box_pack_start(GTK_BOX(vbox), m_closeComplete, FALSE, FALSE, 1);
bool set = false;
m_prefs->GetPrefBoolean(kCloseDLMOnCompletePref, &set);
if (set)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_closeComplete), TRUE);
gtk_widget_show(m_closeComplete);
sep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), sep, FALSE, TRUE, 5);
gtk_widget_show(sep);
GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
m_CancelButton = gtk_button_new_with_label(" Cancel ");
gtk_box_pack_start(GTK_BOX(hbox), m_CancelButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_CancelButton), "clicked",
GTK_SIGNAL_FUNC(cancel_internal), this);
gtk_widget_show(m_CancelButton);
m_PauseButton = gtk_button_new_with_label(" Pause ");
gtk_box_pack_start(GTK_BOX(hbox), m_PauseButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_PauseButton), "clicked",
GTK_SIGNAL_FUNC(pause_internal), this);
gtk_widget_show(m_PauseButton);
m_ResumeButton = gtk_button_new();
m_ResumeLabel = gtk_label_new(" Resume ");
gtk_container_add(GTK_CONTAINER(m_ResumeButton), m_ResumeLabel);
gtk_box_pack_start(GTK_BOX(hbox), m_ResumeButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_ResumeButton), "clicked",
GTK_SIGNAL_FUNC(resume_internal), this);
gtk_widget_show(m_ResumeLabel);
gtk_widget_show(m_ResumeButton);
sep = gtk_vseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), sep, TRUE, FALSE, 5);
gtk_widget_show(sep);
m_CloseButton = gtk_button_new_with_label(" Close ");
gtk_box_pack_end(GTK_BOX(hbox), m_CloseButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_CloseButton), "clicked",
GTK_SIGNAL_FUNC(close_internal), this);
gtk_widget_show(m_CloseButton);
m_helpButton = gtk_button_new_with_label(" Help ");
gtk_box_pack_end(GTK_BOX(hbox), m_helpButton, FALSE, FALSE, 5);
gtk_signal_connect(GTK_OBJECT(m_helpButton), "clicked",
GTK_SIGNAL_FUNC(help_button_click), this);
gtk_widget_show(m_helpButton);
gtk_widget_show(m_downloadUI);
}
void ACDBuildDialog(GtkWidget *dialog)
{
GtkWidget *table1 = gtk_table_new(7, 3, FALSE);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table1, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(table1), 5);
gtk_table_set_row_spacings(GTK_TABLE(table1), 5);
gtk_table_set_col_spacings(GTK_TABLE(table1), 5);
GtkWidget *label1 = gtk_label_new(_("select below"));
gtk_table_attach(GTK_TABLE(table1), label1, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label1), 0, 0.5);
GtkWidget *label2 = gtk_label_new(_("description"));
gtk_table_attach(GTK_TABLE(table1), label2, 2, 3, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label2), 0, 0.5);
rbtnCW = gtk_radio_button_new_with_mnemonic(NULL, _("copy clockwise"));
gtk_table_attach(GTK_TABLE(table1), rbtnCW, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GSList *rbtn1_group = NULL;
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnCW), rbtn1_group);
rbtn1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnCW));
rbtnCCW = gtk_radio_button_new_with_mnemonic(NULL, _("copy counter\nclockwise"));
gtk_table_attach(GTK_TABLE(table1), rbtnCCW, 0, 1, 4, 5,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnCCW), rbtn1_group);
rbtn1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnCCW));
rbtnDETAIL = gtk_radio_button_new_with_mnemonic(NULL, _("copy detail"));
gtk_table_attach(GTK_TABLE(table1), rbtnDETAIL, 0, 1, 6, 7,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnDETAIL), rbtn1_group);
rbtn1_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnDETAIL));
GtkWidget *hbox1 = gtk_hbox_new(FALSE, 5);
gtk_table_attach(GTK_TABLE(table1), hbox1, 2, 3, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
optAC2 = gtk_option_menu_new();
gtk_box_pack_start(GTK_BOX(hbox1), optAC2, FALSE, FALSE, 0);
GtkWidget *label3 = gtk_label_new(_("1.from south direction\n to southwest direction\n2.from west direction\n to northwest direction\n...\n"));
gtk_box_pack_start(GTK_BOX(hbox1), label3, FALSE, TRUE, 0);
GtkWidget *hbox2 = gtk_hbox_new(FALSE, 5);
gtk_table_attach(GTK_TABLE(table1), hbox2, 2, 3, 4, 5,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
optAC3 = gtk_option_menu_new();
gtk_box_pack_start(GTK_BOX(hbox2), optAC3, FALSE, TRUE, 0);
GtkWidget *label4 = gtk_label_new(_("1.from southwest direction\n to south direction\n2.from northwest direction\n to west direction\n...\n"));
gtk_box_pack_start(GTK_BOX(hbox2), label4, FALSE, TRUE, 0);
GtkWidget *hseparator7 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table1), hseparator7, 2, 3, 3, 4,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *hseparator3 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table1), hseparator3, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *hseparator4 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table1), hseparator4, 2, 3, 1, 2,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *hseparator9 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table1), hseparator9, 0, 1, 3, 4,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *vseparator5 = gtk_vseparator_new();
gtk_table_attach(GTK_TABLE(table1), vseparator5, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *vseparator2 = gtk_vseparator_new();
gtk_table_attach(GTK_TABLE(table1), vseparator2, 1, 2, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *vseparator3 = gtk_vseparator_new();
gtk_table_attach(GTK_TABLE(table1), vseparator3, 1, 2, 4, 5,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *vseparator4 = gtk_vseparator_new();
gtk_table_attach(GTK_TABLE(table1), vseparator4, 1, 2, 6, 7,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *hseparator11 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table1), hseparator11, 2, 3, 5, 6,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *hseparator12 = gtk_hseparator_new();
gtk_table_attach(GTK_TABLE(table1), hseparator12, 0, 1, 5, 6,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *hbox3 = gtk_hbox_new(FALSE, 8);
gtk_table_attach(GTK_TABLE(table1), hbox3, 2, 3, 6, 7,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *table2 = gtk_table_new(2, 2, FALSE);
gtk_box_pack_start(GTK_BOX(hbox3), table2, TRUE, TRUE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table2), 5);
gtk_table_set_col_spacings(GTK_TABLE(table2), 5);
GtkWidget *label5 = gtk_label_new(_("From:"));
gtk_table_attach(GTK_TABLE(table2), label5, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label5), 0, 0.5);
optAC11 = gtk_option_menu_new();
gtk_table_attach(GTK_TABLE(table2), optAC11, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *table4 = gtk_table_new(3, 3, FALSE);
gtk_table_attach(GTK_TABLE(table2), table4, 1, 2, 1, 2,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0);
GSList *rbtn0_group = NULL;
for (int i=0; i<3; i++) {
rbtnAC[0][i+3] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table4), rbtnAC[0][i+3], i, i+1, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[0][i+3]), rbtn0_group);
rbtn0_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[0][i+3]));
}
rbtnAC[0][2] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table4), rbtnAC[0][2], 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[0][2]), rbtn0_group);
rbtn0_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[0][2]));
rbtnAC[0][6] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table4), rbtnAC[0][6], 2, 3, 1, 2,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[0][6]), rbtn0_group);
rbtn0_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[0][6]));
rbtnAC[0][1] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table4), rbtnAC[0][1], 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[0][1]), rbtn0_group);
rbtn0_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[0][1]));
rbtnAC[0][0] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table4), rbtnAC[0][0], 1, 2, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[0][0]), rbtn0_group);
rbtn0_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[0][0]));
rbtnAC[0][7] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table4), rbtnAC[0][7], 2, 3, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[0][7]), rbtn0_group);
rbtn0_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[0][7]));
GtkWidget *table3 = gtk_table_new(2, 2, FALSE);
gtk_box_pack_start(GTK_BOX(hbox3), table3, TRUE, TRUE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table3), 5);
gtk_table_set_col_spacings(GTK_TABLE(table3), 5);
GtkWidget *label6 = gtk_label_new(_("To:"));
gtk_table_attach(GTK_TABLE(table3), label6, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label6), 0, 0.5);
optAC12 = gtk_option_menu_new();
gtk_table_attach(GTK_TABLE(table3), optAC12, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GtkWidget *table5 = gtk_table_new(3, 3, FALSE);
gtk_table_attach(GTK_TABLE(table3), table5, 1, 2, 1, 2,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
GSList *rbtn10_group = NULL;
for (int i=0; i<3; i++) {
rbtnAC[1][i+3] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table5), rbtnAC[1][i+3], i, i+1, 0, 1,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[1][i+3]), rbtn10_group);
rbtn10_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[1][i+3]));
}
rbtnAC[1][2] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table5), rbtnAC[1][2], 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[1][2]), rbtn10_group);
rbtn10_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[1][2]));
rbtnAC[1][6] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table5), rbtnAC[1][6], 2, 3, 1, 2,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[1][6]), rbtn10_group);
rbtn10_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[1][6]));
rbtnAC[1][1] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table5), rbtnAC[1][1], 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[1][1]), rbtn10_group);
rbtn10_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[1][1]));
rbtnAC[1][0] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table5), rbtnAC[1][0], 1, 2, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[1][0]), rbtn10_group);
rbtn10_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[1][0]));
rbtnAC[1][7] = gtk_radio_button_new_with_mnemonic(NULL, "");
gtk_table_attach(GTK_TABLE(table5), rbtnAC[1][7], 2, 3, 2, 3,
(GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(0), 0, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(rbtnAC[1][7]), rbtn10_group);
rbtn10_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(rbtnAC[1][7]));
}
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 void show_auth_dialog(WebKitAuthData* authData, const char* login, const char* password)
{
GtkWidget* toplevel;
GtkWidget* widget;
GtkDialog* dialog;
GtkWindow* window;
GtkWidget* entryContainer;
GtkWidget* hbox;
GtkWidget* mainVBox;
GtkWidget* vbox;
GtkWidget* icon;
GtkWidget* table;
GtkWidget* messageLabel;
char* message;
SoupURI* uri;
GtkWidget* rememberBox;
GtkWidget* checkButton;
/* From GTK+ gtkmountoperation.c, modified and simplified. LGPL 2 license */
widget = gtk_dialog_new();
window = GTK_WINDOW(widget);
dialog = GTK_DIALOG(widget);
gtk_dialog_add_buttons(dialog,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
/* Set the dialog up with HIG properties */
gtk_dialog_set_has_separator(dialog, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
gtk_box_set_spacing(GTK_BOX(dialog->vbox), 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width(GTK_CONTAINER(dialog->action_area), 5);
gtk_box_set_spacing(GTK_BOX(dialog->action_area), 6);
gtk_window_set_resizable(window, FALSE);
gtk_window_set_title(window, "");
gtk_window_set_icon_name(window, GTK_STOCK_DIALOG_AUTHENTICATION);
gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK);
/* Get the current toplevel */
g_signal_emit(authData->manager, signals[CURRENT_TOPLEVEL], 0, authData->msg, &toplevel);
if (toplevel)
gtk_window_set_transient_for(window, GTK_WINDOW(toplevel));
/* Build contents */
hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
gtk_box_pack_start(GTK_BOX(dialog->vbox), hbox, TRUE, TRUE, 0);
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);
mainVBox = gtk_vbox_new(FALSE, 18);
gtk_box_pack_start(GTK_BOX(hbox), mainVBox, TRUE, TRUE, 0);
uri = soup_message_get_uri(authData->msg);
message = g_strdup_printf(_("A username and password are being requested by the site %s"), uri->host);
messageLabel = gtk_label_new(message);
g_free(message);
gtk_misc_set_alignment(GTK_MISC(messageLabel), 0.0, 0.5);
gtk_label_set_line_wrap(GTK_LABEL(messageLabel), TRUE);
gtk_box_pack_start(GTK_BOX(mainVBox), GTK_WIDGET(messageLabel),
FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(mainVBox), vbox, FALSE, FALSE, 0);
/* The table that holds the entries */
entryContainer = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(entryContainer),
0, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), entryContainer,
FALSE, FALSE, 0);
table = gtk_table_new(2, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 12);
gtk_table_set_row_spacings(GTK_TABLE(table), 6);
gtk_container_add(GTK_CONTAINER(entryContainer), table);
authData->loginEntry = table_add_entry(table, 0, _("Username:"******"Password:"******"_Remember password"));
if (login && password)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkButton), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(checkButton))), TRUE);
gtk_box_pack_start(GTK_BOX(rememberBox), checkButton, FALSE, FALSE, 0);
authData->checkButton = checkButton;
}
g_signal_connect(dialog, "response", G_CALLBACK(response_callback), authData);
gtk_widget_show_all(widget);
}
/* The public functions */
GtkWidget *
gnome_prefs_entry_new (GtkWidget *table,
const gchar *label_txt,
const gchar *conf_key,
const gchar *tooltip,
int row,
gboolean box)
{
GnomePrefsWindow *gpw = NULL;
GValue value = { 0, {{0}, {0}}};
int cols = 0;
GtkWidget *entry = NULL;
GtkWidget *label = NULL;
GtkWidget *hbox = NULL;
gchar *conf_string = NULL;
gboolean writable = FALSE;
writable = gm_conf_is_key_writable (conf_key);
if (box) {
hbox = gtk_hbox_new (FALSE, 0);
g_value_init (&value, G_TYPE_INT);
g_object_get_property (G_OBJECT (table), "n-columns", &value);
cols = g_value_get_int (&value);
g_value_unset (&value);
}
label = gtk_label_new_with_mnemonic (label_txt);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE);
if (box)
gtk_box_pack_start (GTK_BOX (hbox), label,
FALSE, FALSE, 1 * 2);
else
gtk_table_attach (GTK_TABLE (table), label, 0, 1, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
entry = gtk_entry_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL(label), entry);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (entry), FALSE);
if (box)
gtk_box_pack_start (GTK_BOX (hbox), entry,
FALSE, FALSE, 1 * 2);
else
gtk_table_attach (GTK_TABLE (table), entry, 1, 2, row, row+1,
(GtkAttachOptions) (NULL),
(GtkAttachOptions) (NULL),
0, 0);
conf_string =
gm_conf_get_string (conf_key);
if (conf_string != NULL)
gtk_entry_set_text (GTK_ENTRY (entry), conf_string);
g_free (conf_string);
g_signal_connect_after (entry, "focus-out-event",
G_CALLBACK (entry_focus_changed),
(gpointer)conf_key);
g_signal_connect_after (entry, "activate",
G_CALLBACK (entry_activate_changed),
(gpointer)conf_key);
gm_conf_notifier_add (conf_key, entry_changed_nt, (gpointer) entry);
if (box)
gtk_table_attach (GTK_TABLE (table), hbox, 0, cols, row, row+1,
(GtkAttachOptions) (NULL),
(GtkAttachOptions) (NULL),
0, 0);
gpw = (GnomePrefsWindow *) g_object_get_data (G_OBJECT (table), "gpw");
if (gpw && tooltip)
gtk_widget_set_tooltip_text (entry, tooltip);
gtk_widget_show_all (table);
return entry;
}
GtkMisc* cast_GtkMisc(GtkWidget* widget) {
return GTK_MISC(widget);
}
GtkWidget *
gnome_prefs_spin_new (GtkWidget *table,
const gchar *label_txt,
const gchar *conf_key,
const gchar *tooltip,
double min,
double max,
double step,
int row,
const gchar *label_txt2,
gboolean box)
{
GnomePrefsWindow *gpw = NULL;
GtkWidget *hbox = NULL;
GtkAdjustment *adj = NULL;
GtkWidget *label = NULL;
GtkWidget *spin_button = NULL;
gboolean writable = FALSE;
writable = gm_conf_is_key_writable (conf_key);
if (box)
hbox = gtk_hbox_new (FALSE, 0);
label = gtk_label_new_with_mnemonic (label_txt);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE);
if (box)
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE,
1 * 2);
else
gtk_table_attach (GTK_TABLE (table), label, 0, 1, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
adj = (GtkAdjustment *)
gtk_adjustment_new (gm_conf_get_int (conf_key),
min, max, step,
10.0, 0.0);
spin_button = gtk_spin_button_new (adj, 1.0, 0);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (spin_button), FALSE);
if (box)
gtk_box_pack_start (GTK_BOX (hbox), spin_button, FALSE, FALSE,
1 * 2);
else
gtk_table_attach (GTK_TABLE (table), spin_button, 1, 2, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
if (box && label_txt2) {
label = gtk_label_new_with_mnemonic (label_txt2);
if (!writable)
gtk_widget_set_sensitive (GTK_WIDGET (label), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE,
1 * 2);
}
if (box) {
guint ncols;
g_object_get (G_OBJECT (table), "n-columns", &ncols, NULL);
gtk_table_attach (GTK_TABLE (table), hbox,
0, ncols, row, row+1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL),
0, 0);
}
gpw = (GnomePrefsWindow *) g_object_get_data (G_OBJECT (table), "gpw");
if (gpw && tooltip)
gtk_widget_set_tooltip_text (spin_button, tooltip);
g_signal_connect (adj, "value-changed",
G_CALLBACK (adjustment_changed),
(gpointer) conf_key);
gm_conf_notifier_add (conf_key, adjustment_changed_nt,
(gpointer) adj);
gtk_widget_show_all (table);
return spin_button;
}
void
gnibbles_preferences_cb (GtkWidget * widget, gpointer data)
{
GtkWidget *notebook;
GtkWidget *label;
GtkWidget *frame;
GtkWidget *button;
GtkWidget *levelspinner;
GtkWidget *vbox, *vbox2;
GtkObject *adjustment;
GtkWidget *label2;
GtkWidget *table, *table2;
GtkWidget *omenu;
GtkWidget *controls;
gchar *buffer;
gint i;
gint running = 0;
if (pref_dialog) {
gtk_window_present (GTK_WINDOW (pref_dialog));
return;
}
if (!paused) {
unpause = 1;
pause_game_cb (NULL, 0);
}
if (game_running ())
running = 1;
pref_dialog = gtk_dialog_new_with_buttons (_("Nibbles Preferences"),
GTK_WINDOW (window), 0,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE, NULL);
gtk_dialog_set_has_separator (GTK_DIALOG (pref_dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (pref_dialog), 5);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (pref_dialog)->vbox), 2);
notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (pref_dialog)->vbox),
notebook);
label = gtk_label_new (_("Game"));
table = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 18);
gtk_container_set_border_width (GTK_CONTAINER (table), 12);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), table, label);
frame = games_frame_new (_("Speed"));
if (running)
gtk_widget_set_sensitive (frame, FALSE);
gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 1, 0,
GTK_FILL | GTK_EXPAND, 0, 0);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
button = gtk_radio_button_new_with_label (NULL, _("Nibbles newbie"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
if (properties->gamespeed == 4)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK
(game_speed_cb), (gpointer) 4);
button = gtk_radio_button_new_with_label (gtk_radio_button_get_group
(GTK_RADIO_BUTTON (button)),
_("My second day"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
if (properties->gamespeed == 3)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK
(game_speed_cb), (gpointer) 3);
button = gtk_radio_button_new_with_label (gtk_radio_button_get_group
(GTK_RADIO_BUTTON (button)),
_("Not too shabby"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
if (properties->gamespeed == 2)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK
(game_speed_cb), (gpointer) 2);
button = gtk_radio_button_new_with_label (gtk_radio_button_get_group
(GTK_RADIO_BUTTON (button)),
_("Finger-twitching good"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
if (properties->gamespeed == 1)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK
(game_speed_cb), (gpointer) 1);
/* Options */
frame = games_frame_new (_("Options"));
gtk_table_attach_defaults (GTK_TABLE (table), frame, 1, 2, 0, 1);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox);
button =
gtk_check_button_new_with_mnemonic (_("_Play levels in random order"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
if (running || ggz_network_mode)
gtk_widget_set_sensitive (button, FALSE);
if (properties->random)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK
(random_order_cb), NULL);
button = gtk_check_button_new_with_mnemonic (_("_Enable fake bonuses"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
if (running)
gtk_widget_set_sensitive (button, FALSE);
if (properties->fakes)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK
(fake_bonus_cb), NULL);
button = gtk_check_button_new_with_mnemonic (_("E_nable sounds"));
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
if (properties->sound)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect (GTK_OBJECT (button), "toggled", G_CALLBACK
(sound_cb), NULL);
table2 = gtk_table_new (3, 2, FALSE);
gtk_box_pack_start (GTK_BOX (vbox), table2, FALSE, FALSE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table2), 6);
gtk_table_set_col_spacings (GTK_TABLE (table2), 12);
gtk_container_set_border_width (GTK_CONTAINER (table2), 0);
label2 = gtk_label_new_with_mnemonic (_("_Starting level:"));
start_level_label = label2;
gtk_widget_set_name (label2, "StartLevelLabel");
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
if (properties->random)
gtk_widget_set_sensitive (GTK_WIDGET (label2), FALSE);
if (running)
gtk_widget_set_sensitive (GTK_WIDGET (label2), FALSE);
gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 0, 1, GTK_FILL, 0, 0,
0);
adjustment = gtk_adjustment_new ((gfloat) properties->startlevel, 1.0,
MAXLEVEL, 1.0, 5.0, 0.0);
levelspinner = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 0, 0);
start_level_spin_button = levelspinner;
gtk_widget_set_name (levelspinner, "StartLevelSpinButton");
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (levelspinner), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label2), levelspinner);
if (properties->random)
gtk_widget_set_sensitive (GTK_WIDGET (levelspinner), FALSE);
if (running)
gtk_widget_set_sensitive (GTK_WIDGET (levelspinner), FALSE);
gtk_table_attach_defaults (GTK_TABLE (table2), levelspinner, 1, 2, 0, 1);
g_signal_connect (GTK_OBJECT (adjustment), "value_changed",
G_CALLBACK (start_level_cb), levelspinner);
label2 = gtk_label_new_with_mnemonic (_("Number of _human players:"));
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 1, 2, GTK_FILL, 0, 0,
0);
if (running || ggz_network_mode)
gtk_widget_set_sensitive (label2, FALSE);
adjustment = gtk_adjustment_new ((gfloat) properties->human, 0.0,
NUMWORMS, 1.0, 1.0, 0.0);
num_human = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (num_human), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label2), num_human);
gtk_table_attach_defaults (GTK_TABLE (table2), num_human, 1, 2, 1, 2);
if (running || ggz_network_mode)
gtk_widget_set_sensitive (num_human, FALSE);
g_signal_connect (GTK_OBJECT (adjustment), "value_changed",
G_CALLBACK (num_worms_cb), num_human);
label2 = gtk_label_new_with_mnemonic (_("Number of _AI players:"));
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 2, 3, GTK_FILL, 0, 0,
0);
if (running || ggz_network_mode)
gtk_widget_set_sensitive (label2, FALSE);
adjustment = gtk_adjustment_new ((gfloat) properties->ai, 0.0,
NUMWORMS, 1.0, 1.0, 0.0);
num_ai = gtk_spin_button_new (GTK_ADJUSTMENT (adjustment), 0, 0);
gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (num_ai), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL (label2), num_ai);
gtk_table_attach_defaults (GTK_TABLE (table2), num_ai, 1, 2, 2, 3);
if (running || ggz_network_mode)
gtk_widget_set_sensitive (num_ai, FALSE);
g_signal_connect (GTK_OBJECT (adjustment), "value_changed",
G_CALLBACK (num_worms_cb), num_ai);
for (i = 0; i < NUMWORMS; i++) {
char up_key[64];
char down_key[64];
char left_key[64];
char right_key[64];
buffer = g_strdup_printf ("%s %d", _("Worm"), i + 1);
label = gtk_label_new (buffer);
g_free (buffer);
vbox = gtk_vbox_new (FALSE, 18);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, label);
frame = games_frame_new (_("Keyboard Controls"));
controls = games_controls_list_new (KEY_PREFERENCES_GROUP);
g_snprintf (left_key, sizeof (left_key), KEY_WORM_LEFT, i);
g_snprintf (right_key, sizeof (right_key), KEY_WORM_RIGHT, i);
g_snprintf (up_key, sizeof (up_key), KEY_WORM_UP, i);
g_snprintf (down_key, sizeof (down_key), KEY_WORM_DOWN, i);
games_controls_list_add_controls (GAMES_CONTROLS_LIST (controls),
left_key, _("Move left"), GDK_Left,
right_key, _("Move right"), GDK_Right,
up_key, _("Move up"), GDK_Up,
down_key, _("Move down"), GDK_Down,
NULL);
gtk_container_add (GTK_CONTAINER (frame), controls);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
frame = games_frame_new (_("Options"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
vbox2 = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (frame), vbox2);
button = gtk_check_button_new_with_mnemonic (_("_Use relative movement"));
gtk_box_pack_start (GTK_BOX (vbox2), button, FALSE, FALSE, 0);
table2 = gtk_table_new (1, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table2), 12);
gtk_box_pack_start (GTK_BOX (vbox2), table2, FALSE, FALSE, 0);
label2 = gtk_label_new_with_mnemonic (_("_Worm color:"));
gtk_misc_set_alignment (GTK_MISC (label2), 0, 0.5);
gtk_table_attach (GTK_TABLE (table2), label2, 0, 1, 0, 1, 0, 0, 0, 0);
omenu = gtk_combo_box_new_text ();
gtk_label_set_mnemonic_widget (GTK_LABEL (label2), omenu);
gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Red"));
gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Green"));
gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Blue"));
gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Yellow"));
gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Cyan"));
gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Purple"));
gtk_combo_box_append_text (GTK_COMBO_BOX (omenu), _("Gray"));
g_signal_connect (GTK_OBJECT (omenu), "changed",
G_CALLBACK (set_worm_color_cb),
GINT_TO_POINTER (i));
gtk_combo_box_set_active (GTK_COMBO_BOX (omenu),
properties->wormprops[i]->color - WORMRED);
gtk_table_attach_defaults (GTK_TABLE (table2), omenu, 1, 2, 0, 1);
set_worm_controls_sensitivity (i, properties->wormprops[i]->relmove);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button),
properties->wormprops[i]->relmove);
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (worm_relative_movement_cb),
GINT_TO_POINTER (i));
}
g_signal_connect (G_OBJECT (pref_dialog), "response",
G_CALLBACK (apply_cb), NULL);
g_signal_connect (G_OBJECT (pref_dialog), "destroy",
G_CALLBACK (destroy_cb), NULL);
g_signal_connect (G_OBJECT (pref_dialog), "close",
G_CALLBACK (destroy_cb), NULL);
gtk_widget_show_all (pref_dialog);
}
GtkWidget *
gnome_prefs_window_new (const gchar *logo_name)
{
GnomePrefsWindow *gpw = NULL;
GtkTreeSelection *selection = NULL;
GtkCellRenderer *cell = NULL;
GtkTreeStore *model = NULL;
GtkTreeViewColumn *column = NULL;
GtkWidget *window = NULL;
GtkWidget *event_box = NULL;
GtkWidget *hbox = NULL;
GtkWidget *vbox = NULL;
GtkWidget *frame = NULL;
GtkWidget *pixmap = NULL;
GtkWidget *hsep = NULL;
GdkColor cwhite;
PangoAttrList *attrs = NULL;
PangoAttribute *attr = NULL;
/* Box inside the prefs window */
GtkWidget *dialog_vbox = NULL;
/* Build the window */
window = gtk_dialog_new ();
gpw = (GnomePrefsWindow *) g_malloc (sizeof (GnomePrefsWindow));
gpw->last_page = 1;
g_object_set_data_full (G_OBJECT (window), "gpw", (gpointer) gpw, g_free);
gtk_dialog_add_button (GTK_DIALOG (window), GTK_STOCK_CLOSE, GTK_RESPONSE_CANCEL);
/* The sections */
gpw->notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (gpw->notebook), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (gpw->notebook), FALSE);
pixmap = gtk_image_new_from_file (logo_name);
event_box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (event_box),
GTK_WIDGET (pixmap));
cwhite.red = 0xff * 0x100;
cwhite.green = 0xff * 0x100;
cwhite.blue = 0xff * 0x100;
gdk_colormap_alloc_color(gdk_colormap_get_system (), &cwhite, FALSE, TRUE);
gtk_widget_modify_bg (GTK_WIDGET (event_box),
GTK_STATE_NORMAL, &cwhite);
gtk_notebook_prepend_page (GTK_NOTEBOOK (gpw->notebook), event_box, NULL);
/* The sections */
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (window));
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_container_add (GTK_CONTAINER (dialog_vbox), hbox);
/* Build the TreeView on the left */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
model = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_INT);
gpw->sections_tree_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (gpw->sections_tree_view),
GTK_TREE_MODEL (model));
selection =
gtk_tree_view_get_selection (GTK_TREE_VIEW (gpw->sections_tree_view));
gtk_container_add (GTK_CONTAINER (frame), gpw->sections_tree_view);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gpw->sections_tree_view),
FALSE);
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL, cell, "text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (gpw->sections_tree_view),
GTK_TREE_VIEW_COLUMN (column));
gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection),
GTK_SELECTION_BROWSE);
/* Some design stuff to put the notebook pages in it */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
vbox = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (frame), vbox);
gtk_widget_show (vbox);
gpw->section_label = gtk_label_new (NULL);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_misc_set_alignment (GTK_MISC (gpw->section_label), 0.0, 0.5);
gtk_container_add (GTK_CONTAINER (frame), gpw->section_label);
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
attrs = pango_attr_list_new ();
attr = pango_attr_scale_new (PANGO_SCALE_LARGE);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert (attrs, attr);
attr = pango_attr_weight_new (PANGO_WEIGHT_HEAVY);
attr->start_index = 0;
attr->end_index = G_MAXUINT;
pango_attr_list_insert (attrs, attr);
gtk_label_set_attributes (GTK_LABEL (gpw->section_label), attrs);
pango_attr_list_unref (attrs);
gtk_widget_show (gpw->section_label);
hsep = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), hsep, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), gpw->notebook, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (dialog_vbox));
gtk_widget_show_all (GTK_WIDGET (gpw->sections_tree_view));
g_signal_connect (selection, "changed",
G_CALLBACK (tree_selection_changed_cb),
gpw);
return window;
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *alignment4;
GtkWidget *vbox1;
GtkWidget *frame1;
GtkWidget *alignment2;
GtkWidget *table1;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *label7;
GtkWidget *label_fps;
GtkWidget *label_size;
GtkWidget *label3;
GtkWidget *label_number;
GtkWidget *label_duration;
GtkWidget *label6;
GtkWidget *label_videofourcc;
GtkWidget *label35;
GtkWidget *labelAspectRatio;
GtkWidget *label1;
GtkWidget *frame3;
GtkWidget *alignment5;
GtkWidget *table3;
GtkWidget *labelGMCCap;
GtkWidget *labelGMC;
GtkWidget *labelPackedBitstreamCap;
GtkWidget *labelPacked;
GtkWidget *labelQPelCap;
GtkWidget *labelQP;
GtkWidget *label41;
GtkWidget *frame2;
GtkWidget *alignment3;
GtkWidget *table2;
GtkWidget *label13;
GtkWidget *label14;
GtkWidget *label15;
GtkWidget *label16;
GtkWidget *label17;
GtkWidget *label1_audiofourcc;
GtkWidget *label1_audiomode;
GtkWidget *label_bitrate;
GtkWidget *label_fq;
GtkWidget *label_audioduration;
GtkWidget *label40;
GtkWidget *labelFileSize;
GtkWidget *label21;
GtkWidget *labelVbr;
GtkWidget *label2;
GtkWidget *dialog_action_area1;
GtkWidget *okbutton1;
dialog1 = gtk_dialog_new ();
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Properties"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_widget_show (dialog_vbox1);
alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment4);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), alignment4, TRUE, TRUE, 0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 2, 10, 6, 6);
vbox1 = gtk_vbox_new (FALSE, 2);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (alignment4), vbox1);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (vbox1), frame1, TRUE, TRUE, 0);
alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (frame1), alignment2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 3, 6, 12, 12);
table1 = gtk_table_new (6, 2, FALSE);
gtk_widget_show (table1);
gtk_container_add (GTK_CONTAINER (alignment2), table1);
gtk_table_set_col_spacings (GTK_TABLE (table1), 12);
label4 = gtk_label_new (QT_TR_NOOP("Frame Rate:"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
label5 = gtk_label_new (QT_TR_NOOP("Frame Count:"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label7 = gtk_label_new (QT_TR_NOOP("Total Duration:"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
label_fps = gtk_label_new ("");
gtk_widget_show (label_fps);
gtk_table_attach (GTK_TABLE (table1), label_fps, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_fps), 0, 0.5);
label_size = gtk_label_new (QT_TR_NOOP(" "));
gtk_widget_show (label_size);
gtk_table_attach (GTK_TABLE (table1), label_size, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_size), 0, 0.5);
label3 = gtk_label_new (QT_TR_NOOP("Image Size:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label_number = gtk_label_new ("");
gtk_widget_show (label_number);
gtk_table_attach (GTK_TABLE (table1), label_number, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_number), 0, 0.5);
label_duration = gtk_label_new (QT_TR_NOOP(" "));
gtk_widget_show (label_duration);
gtk_table_attach (GTK_TABLE (table1), label_duration, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_duration), 0, 0.5);
label6 = gtk_label_new (QT_TR_NOOP("Codec 4CC:"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
label_videofourcc = gtk_label_new ("");
gtk_widget_show (label_videofourcc);
gtk_table_attach (GTK_TABLE (table1), label_videofourcc, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_videofourcc), 0, 0.5);
label35 = gtk_label_new (QT_TR_NOOP("Aspect Ratio:"));
gtk_widget_show (label35);
gtk_table_attach (GTK_TABLE (table1), label35, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label35), 0, 0.5);
labelAspectRatio = gtk_label_new ("");
gtk_widget_show (labelAspectRatio);
gtk_table_attach (GTK_TABLE (table1), labelAspectRatio, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelAspectRatio), 0, 0.5);
label1 = gtk_label_new (QT_TR_NOOP("<b>Video</b>"));
gtk_widget_show (label1);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label1);
gtk_label_set_use_markup (GTK_LABEL (label1), TRUE);
frame3 = gtk_frame_new (NULL);
gtk_widget_show (frame3);
gtk_box_pack_start (GTK_BOX (vbox1), frame3, TRUE, TRUE, 2);
alignment5 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment5);
gtk_container_add (GTK_CONTAINER (frame3), alignment5);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment5), 3, 6, 12, 12);
table3 = gtk_table_new (3, 2, FALSE);
gtk_widget_show (table3);
gtk_container_add (GTK_CONTAINER (alignment5), table3);
gtk_table_set_col_spacings (GTK_TABLE (table3), 12);
labelGMCCap = gtk_label_new (QT_TR_NOOP("Global Motion Compensation:"));
gtk_widget_show (labelGMCCap);
gtk_table_attach (GTK_TABLE (table3), labelGMCCap, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelGMCCap), 0, 0.5);
labelGMC = gtk_label_new ("");
gtk_widget_show (labelGMC);
gtk_table_attach (GTK_TABLE (table3), labelGMC, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelGMC), 0, 0.5);
labelPackedBitstreamCap = gtk_label_new (QT_TR_NOOP("Packed Bitstream:"));
gtk_widget_show (labelPackedBitstreamCap);
gtk_table_attach (GTK_TABLE (table3), labelPackedBitstreamCap, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelPackedBitstreamCap), 0, 0.5);
labelPacked = gtk_label_new ("");
gtk_widget_show (labelPacked);
gtk_table_attach (GTK_TABLE (table3), labelPacked, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelPacked), 0, 0.5);
labelQPelCap = gtk_label_new (QT_TR_NOOP("Quarter Pixel:"));
gtk_widget_show (labelQPelCap);
gtk_table_attach (GTK_TABLE (table3), labelQPelCap, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelQPelCap), 0, 0.5);
labelQP = gtk_label_new ("");
gtk_widget_show (labelQP);
gtk_table_attach (GTK_TABLE (table3), labelQP, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelQP), 0, 0.5);
label41 = gtk_label_new (QT_TR_NOOP("<b>Extra Video Properties</b>"));
gtk_widget_show (label41);
gtk_frame_set_label_widget (GTK_FRAME (frame3), label41);
gtk_label_set_use_markup (GTK_LABEL (label41), TRUE);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (vbox1), frame2, TRUE, TRUE, 0);
alignment3 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment3);
gtk_container_add (GTK_CONTAINER (frame2), alignment3);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment3), 3, 6, 12, 12);
table2 = gtk_table_new (7, 2, FALSE);
gtk_widget_show (table2);
gtk_container_add (GTK_CONTAINER (alignment3), table2);
gtk_table_set_col_spacings (GTK_TABLE (table2), 12);
label13 = gtk_label_new (QT_TR_NOOP("Codec:"));
gtk_widget_show (label13);
gtk_table_attach (GTK_TABLE (table2), label13, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label13), 0, 0.5);
label14 = gtk_label_new (QT_TR_NOOP("Channels:"));
gtk_widget_show (label14);
gtk_table_attach (GTK_TABLE (table2), label14, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label14), 0, 0.5);
label15 = gtk_label_new (QT_TR_NOOP("Bitrate:"));
gtk_widget_show (label15);
gtk_table_attach (GTK_TABLE (table2), label15, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label15), 0, 0.5);
label16 = gtk_label_new (QT_TR_NOOP("Frequency:"));
gtk_widget_show (label16);
gtk_table_attach (GTK_TABLE (table2), label16, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5);
label17 = gtk_label_new (QT_TR_NOOP("Total Duration:"));
gtk_widget_show (label17);
gtk_table_attach (GTK_TABLE (table2), label17, 0, 1, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label17), 0, 0.5);
label1_audiofourcc = gtk_label_new ("");
gtk_widget_show (label1_audiofourcc);
gtk_table_attach (GTK_TABLE (table2), label1_audiofourcc, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1_audiofourcc), 0, 0.5);
label1_audiomode = gtk_label_new ("");
gtk_widget_show (label1_audiomode);
gtk_table_attach (GTK_TABLE (table2), label1_audiomode, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label1_audiomode), 0, 0.5);
label_bitrate = gtk_label_new ("");
gtk_widget_show (label_bitrate);
gtk_table_attach (GTK_TABLE (table2), label_bitrate, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_bitrate), 0, 0.5);
label_fq = gtk_label_new ("");
gtk_widget_show (label_fq);
gtk_table_attach (GTK_TABLE (table2), label_fq, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_fq), 0, 0.5);
label_audioduration = gtk_label_new ("");
gtk_widget_show (label_audioduration);
gtk_table_attach (GTK_TABLE (table2), label_audioduration, 1, 2, 5, 6,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label_audioduration), 0, 0.5);
label40 = gtk_label_new (QT_TR_NOOP("File Size:"));
gtk_widget_show (label40);
gtk_table_attach (GTK_TABLE (table2), label40, 0, 1, 6, 7,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label40), 0, 0.5);
labelFileSize = gtk_label_new ("");
gtk_widget_show (labelFileSize);
gtk_table_attach (GTK_TABLE (table2), labelFileSize, 1, 2, 6, 7,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelFileSize), 0, 0.5);
label21 = gtk_label_new (QT_TR_NOOP("Variable Bitrate:"));
gtk_widget_show (label21);
gtk_table_attach (GTK_TABLE (table2), label21, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label21), 0, 0.5);
labelVbr = gtk_label_new ("");
gtk_widget_show (labelVbr);
gtk_table_attach (GTK_TABLE (table2), labelVbr, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelVbr), 0, 0.5);
label2 = gtk_label_new (QT_TR_NOOP("<b>Audio</b>"));
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label2);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
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);
okbutton1 = gtk_button_new_from_stock ("gtk-ok");
gtk_widget_show (okbutton1);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, alignment4, "alignment4");
GLADE_HOOKUP_OBJECT (dialog1, vbox1, "vbox1");
GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1");
GLADE_HOOKUP_OBJECT (dialog1, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (dialog1, table1, "table1");
GLADE_HOOKUP_OBJECT (dialog1, label4, "label4");
GLADE_HOOKUP_OBJECT (dialog1, label5, "label5");
GLADE_HOOKUP_OBJECT (dialog1, label7, "label7");
GLADE_HOOKUP_OBJECT (dialog1, label_fps, "label_fps");
GLADE_HOOKUP_OBJECT (dialog1, label_size, "label_size");
GLADE_HOOKUP_OBJECT (dialog1, label3, "label3");
GLADE_HOOKUP_OBJECT (dialog1, label_number, "label_number");
GLADE_HOOKUP_OBJECT (dialog1, label_duration, "label_duration");
GLADE_HOOKUP_OBJECT (dialog1, label6, "label6");
GLADE_HOOKUP_OBJECT (dialog1, label_videofourcc, "label_videofourcc");
GLADE_HOOKUP_OBJECT (dialog1, label35, "label35");
GLADE_HOOKUP_OBJECT (dialog1, labelAspectRatio, "labelAspectRatio");
GLADE_HOOKUP_OBJECT (dialog1, label1, "label1");
GLADE_HOOKUP_OBJECT (dialog1, frame3, "frame3");
GLADE_HOOKUP_OBJECT (dialog1, alignment5, "alignment5");
GLADE_HOOKUP_OBJECT (dialog1, table3, "table3");
GLADE_HOOKUP_OBJECT (dialog1, labelGMCCap, "labelGMCCap");
GLADE_HOOKUP_OBJECT (dialog1, labelGMC, "labelGMC");
GLADE_HOOKUP_OBJECT (dialog1, labelPackedBitstreamCap, "labelPackedBitstreamCap");
GLADE_HOOKUP_OBJECT (dialog1, labelPacked, "labelPacked");
GLADE_HOOKUP_OBJECT (dialog1, labelQPelCap, "labelQPelCap");
GLADE_HOOKUP_OBJECT (dialog1, labelQP, "labelQP");
GLADE_HOOKUP_OBJECT (dialog1, label41, "label41");
GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2");
GLADE_HOOKUP_OBJECT (dialog1, alignment3, "alignment3");
GLADE_HOOKUP_OBJECT (dialog1, table2, "table2");
GLADE_HOOKUP_OBJECT (dialog1, label13, "label13");
GLADE_HOOKUP_OBJECT (dialog1, label14, "label14");
GLADE_HOOKUP_OBJECT (dialog1, label15, "label15");
GLADE_HOOKUP_OBJECT (dialog1, label16, "label16");
GLADE_HOOKUP_OBJECT (dialog1, label17, "label17");
GLADE_HOOKUP_OBJECT (dialog1, label1_audiofourcc, "label1_audiofourcc");
GLADE_HOOKUP_OBJECT (dialog1, label1_audiomode, "label1_audiomode");
GLADE_HOOKUP_OBJECT (dialog1, label_bitrate, "label_bitrate");
GLADE_HOOKUP_OBJECT (dialog1, label_fq, "label_fq");
GLADE_HOOKUP_OBJECT (dialog1, label_audioduration, "label_audioduration");
GLADE_HOOKUP_OBJECT (dialog1, label40, "label40");
GLADE_HOOKUP_OBJECT (dialog1, labelFileSize, "labelFileSize");
GLADE_HOOKUP_OBJECT (dialog1, label21, "label21");
GLADE_HOOKUP_OBJECT (dialog1, labelVbr, "labelVbr");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");
gtk_widget_grab_focus (okbutton1);
gtk_widget_grab_default (okbutton1);
return dialog1;
}