GtkWidget*
create_windowStats (void)
{
GtkWidget *windowStats;
GtkWidget *vboxStats;
GtkWidget *labelUserValue;
GtkWidget *hseparator1;
GtkWidget *hboxHabitData;
GtkWidget *treeviewHabits;
GtkWidget *tableData;
GtkWidget *labelClean;
GtkWidget *labelSaved;
GtkWidget *labelDaily;
GtkWidget *labelUnits;
GtkWidget *labelCleanValue;
GtkWidget *labelSavedValue;
GtkWidget *labelDailyValue;
GtkWidget *labelUnitsValue;
GtkWidget *frameTotals;
GtkWidget *tableTotals;
GtkWidget *labelCleanTotal;
GtkWidget *labelSavedTotal;
GtkWidget *labelSavedValueTotal;
GtkWidget *labelCleanValueTotal;
GtkWidget *label20;
GtkWidget *hbuttonbox2;
GtkWidget *buttonClose;
windowStats = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (windowStats, "windowStats");
gtk_window_set_title (GTK_WINDOW (windowStats), "Stats");
gtk_window_set_resizable (GTK_WINDOW (windowStats), FALSE);
vboxStats = gtk_vbox_new (FALSE, 5);
gtk_widget_set_name (vboxStats, "vboxStats");
gtk_widget_show (vboxStats);
gtk_container_add (GTK_CONTAINER (windowStats), vboxStats);
gtk_container_set_border_width (GTK_CONTAINER (vboxStats), 3);
labelUserValue = gtk_label_new ("<span size=\"large\">User name</span>");
gtk_widget_set_name (labelUserValue, "labelUserValue");
gtk_widget_show (labelUserValue);
gtk_box_pack_start (GTK_BOX (vboxStats), labelUserValue, TRUE, TRUE, 1);
gtk_label_set_use_markup (GTK_LABEL (labelUserValue), TRUE);
hseparator1 = gtk_hseparator_new ();
gtk_widget_set_name (hseparator1, "hseparator1");
gtk_widget_show (hseparator1);
gtk_box_pack_start (GTK_BOX (vboxStats), hseparator1, TRUE, TRUE, 0);
hboxHabitData = gtk_hbox_new (FALSE, 5);
gtk_widget_set_name (hboxHabitData, "hboxHabitData");
gtk_widget_show (hboxHabitData);
gtk_box_pack_start (GTK_BOX (vboxStats), hboxHabitData, FALSE, FALSE, 0);
treeviewHabits = gtk_tree_view_new ();
gtk_widget_set_name (treeviewHabits, "treeviewHabits");
gtk_widget_show (treeviewHabits);
gtk_box_pack_start (GTK_BOX (hboxHabitData), treeviewHabits, TRUE, TRUE, 0);
tableData = gtk_table_new (4, 2, FALSE);
gtk_widget_set_name (tableData, "tableData");
gtk_widget_show (tableData);
gtk_box_pack_start (GTK_BOX (hboxHabitData), tableData, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (tableData), 5);
gtk_table_set_row_spacings (GTK_TABLE (tableData), 5);
gtk_table_set_col_spacings (GTK_TABLE (tableData), 10);
labelClean = gtk_label_new ("Clean time:");
gtk_widget_set_name (labelClean, "labelClean");
gtk_widget_show (labelClean);
gtk_table_attach (GTK_TABLE (tableData), labelClean, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (labelClean), TRUE);
gtk_misc_set_alignment (GTK_MISC (labelClean), 0, 0.5);
labelSaved = gtk_label_new ("Money saved:");
gtk_widget_set_name (labelSaved, "labelSaved");
gtk_widget_show (labelSaved);
gtk_table_attach (GTK_TABLE (tableData), labelSaved, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (labelSaved), TRUE);
gtk_misc_set_alignment (GTK_MISC (labelSaved), 0, 0.5);
labelDaily = gtk_label_new ("Daily save:");
gtk_widget_set_name (labelDaily, "labelDaily");
gtk_widget_show (labelDaily);
gtk_table_attach (GTK_TABLE (tableData), labelDaily, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (labelDaily), TRUE);
gtk_misc_set_alignment (GTK_MISC (labelDaily), 0, 0.5);
labelUnits = gtk_label_new ("Units not used:");
gtk_widget_set_name (labelUnits, "labelUnits");
gtk_widget_show (labelUnits);
gtk_table_attach (GTK_TABLE (tableData), labelUnits, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelUnits), 0, 0.5);
labelCleanValue = gtk_label_new ("0M 0W 0D 0h 0m");
gtk_widget_set_name (labelCleanValue, "labelCleanValue");
gtk_widget_show (labelCleanValue);
gtk_table_attach (GTK_TABLE (tableData), labelCleanValue, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelCleanValue), 0, 0.5);
labelSavedValue = gtk_label_new ("0.00");
gtk_widget_set_name (labelSavedValue, "labelSavedValue");
gtk_widget_show (labelSavedValue);
gtk_table_attach (GTK_TABLE (tableData), labelSavedValue, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelSavedValue), 0, 0.5);
labelDailyValue = gtk_label_new ("0.00");
gtk_widget_set_name (labelDailyValue, "labelDailyValue");
gtk_widget_show (labelDailyValue);
gtk_table_attach (GTK_TABLE (tableData), labelDailyValue, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelDailyValue), 0, 0.5);
labelUnitsValue = gtk_label_new ("0");
gtk_widget_set_name (labelUnitsValue, "labelUnitsValue");
gtk_widget_show (labelUnitsValue);
gtk_table_attach (GTK_TABLE (tableData), labelUnitsValue, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelUnitsValue), 0, 0.5);
frameTotals = gtk_frame_new (NULL);
gtk_widget_set_name (frameTotals, "frameTotals");
gtk_widget_show (frameTotals);
gtk_box_pack_start (GTK_BOX (vboxStats), frameTotals, TRUE, TRUE, 0);
tableTotals = gtk_table_new (2, 2, FALSE);
gtk_widget_set_name (tableTotals, "tableTotals");
gtk_widget_show (tableTotals);
gtk_container_add (GTK_CONTAINER (frameTotals), tableTotals);
gtk_container_set_border_width (GTK_CONTAINER (tableTotals), 5);
gtk_table_set_row_spacings (GTK_TABLE (tableTotals), 5);
gtk_table_set_col_spacings (GTK_TABLE (tableTotals), 10);
labelCleanTotal = gtk_label_new ("Clean time:");
gtk_widget_set_name (labelCleanTotal, "labelCleanTotal");
gtk_widget_show (labelCleanTotal);
gtk_table_attach (GTK_TABLE (tableTotals), labelCleanTotal, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (labelCleanTotal), TRUE);
gtk_misc_set_alignment (GTK_MISC (labelCleanTotal), 0, 0.5);
labelSavedTotal = gtk_label_new ("Money saved:");
gtk_widget_set_name (labelSavedTotal, "labelSavedTotal");
gtk_widget_show (labelSavedTotal);
gtk_table_attach (GTK_TABLE (tableTotals), labelSavedTotal, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (labelSavedTotal), TRUE);
gtk_misc_set_alignment (GTK_MISC (labelSavedTotal), 0, 0.5);
labelSavedValueTotal = gtk_label_new ("0.00");
gtk_widget_set_name (labelSavedValueTotal, "labelSavedValueTotal");
gtk_widget_show (labelSavedValueTotal);
gtk_table_attach (GTK_TABLE (tableTotals), labelSavedValueTotal, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelSavedValueTotal), 0, 0.5);
labelCleanValueTotal = gtk_label_new ("0M 0W 0D 0h 0m");
gtk_widget_set_name (labelCleanValueTotal, "labelCleanValueTotal");
gtk_widget_show (labelCleanValueTotal);
gtk_table_attach (GTK_TABLE (tableTotals), labelCleanValueTotal, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelCleanValueTotal), 0, 0.5);
label20 = gtk_label_new (" <b>Totals</b> ");
gtk_widget_set_name (label20, "label20");
gtk_widget_show (label20);
gtk_frame_set_label_widget (GTK_FRAME (frameTotals), label20);
gtk_label_set_use_markup (GTK_LABEL (label20), TRUE);
hbuttonbox2 = gtk_hbutton_box_new ();
gtk_widget_set_name (hbuttonbox2, "hbuttonbox2");
gtk_widget_show (hbuttonbox2);
gtk_box_pack_start (GTK_BOX (vboxStats), hbuttonbox2, TRUE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox2), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox2), 5);
buttonClose = gtk_button_new_from_stock ("gtk-close");
gtk_widget_set_name (buttonClose, "buttonClose");
gtk_widget_show (buttonClose);
gtk_container_add (GTK_CONTAINER (hbuttonbox2), buttonClose);
GTK_WIDGET_SET_FLAGS (buttonClose, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (windowStats, windowStats, "windowStats");
GLADE_HOOKUP_OBJECT (windowStats, vboxStats, "vboxStats");
GLADE_HOOKUP_OBJECT (windowStats, labelUserValue, "labelUserValue");
GLADE_HOOKUP_OBJECT (windowStats, hseparator1, "hseparator1");
GLADE_HOOKUP_OBJECT (windowStats, hboxHabitData, "hboxHabitData");
GLADE_HOOKUP_OBJECT (windowStats, treeviewHabits, "treeviewHabits");
GLADE_HOOKUP_OBJECT (windowStats, tableData, "tableData");
GLADE_HOOKUP_OBJECT (windowStats, labelClean, "labelClean");
GLADE_HOOKUP_OBJECT (windowStats, labelSaved, "labelSaved");
GLADE_HOOKUP_OBJECT (windowStats, labelDaily, "labelDaily");
GLADE_HOOKUP_OBJECT (windowStats, labelUnits, "labelUnits");
GLADE_HOOKUP_OBJECT (windowStats, labelCleanValue, "labelCleanValue");
GLADE_HOOKUP_OBJECT (windowStats, labelSavedValue, "labelSavedValue");
GLADE_HOOKUP_OBJECT (windowStats, labelDailyValue, "labelDailyValue");
GLADE_HOOKUP_OBJECT (windowStats, labelUnitsValue, "labelUnitsValue");
GLADE_HOOKUP_OBJECT (windowStats, frameTotals, "frameTotals");
GLADE_HOOKUP_OBJECT (windowStats, tableTotals, "tableTotals");
GLADE_HOOKUP_OBJECT (windowStats, labelCleanTotal, "labelCleanTotal");
GLADE_HOOKUP_OBJECT (windowStats, labelSavedTotal, "labelSavedTotal");
GLADE_HOOKUP_OBJECT (windowStats, labelSavedValueTotal, "labelSavedValueTotal");
GLADE_HOOKUP_OBJECT (windowStats, labelCleanValueTotal, "labelCleanValueTotal");
GLADE_HOOKUP_OBJECT (windowStats, label20, "label20");
GLADE_HOOKUP_OBJECT (windowStats, hbuttonbox2, "hbuttonbox2");
GLADE_HOOKUP_OBJECT (windowStats, buttonClose, "buttonClose");
return windowStats;
}
static void
mateconf_bookmarks_dialog_init (MateConfBookmarksDialog *dialog)
{
GtkWidget *scrolled_window, *hbox, *vbox;
GtkWidget *content_area;
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
MateConfClient *client;
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (content_area), 2);
gtk_window_set_destroy_with_parent (GTK_WINDOW (dialog), TRUE);
gtk_window_set_default_size (GTK_WINDOW (dialog), 300, 200);
gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_window_set_title (GTK_WINDOW (dialog), _("Edit Bookmarks"));
dialog->list_store = gtk_list_store_new (1, G_TYPE_STRING);
g_signal_connect (dialog->list_store, "row_deleted",
G_CALLBACK (mateconf_bookmarks_dialog_row_deleted), dialog);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (hbox), scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
dialog->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (dialog->list_store));
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (dialog->tree_view), TRUE);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view)), "changed",
G_CALLBACK (mateconf_bookmarks_dialog_selection_changed), dialog);
mateconf_bookmarks_dialog_populate_model (dialog);
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_pixbuf_new ();
g_object_set (G_OBJECT (cell),
"stock-id", STOCK_BOOKMARK,
NULL);
gtk_tree_view_column_pack_start (column, cell, FALSE);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->tree_view), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (dialog->tree_view), FALSE);
g_object_unref (dialog->list_store);
gtk_container_add (GTK_CONTAINER (scrolled_window), dialog->tree_view);
vbox = gtk_vbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
dialog->delete_button = gtk_button_new_from_stock (GTK_STOCK_DELETE);
gtk_widget_set_sensitive (dialog->delete_button, FALSE);
g_signal_connect (dialog->delete_button, "clicked",
G_CALLBACK (mateconf_bookmarks_dialog_delete_bookmark), dialog);
gtk_box_pack_start (GTK_BOX (vbox), dialog->delete_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (content_area), hbox, TRUE, TRUE, 0);
gtk_widget_show_all (hbox);
/* Listen for mateconf changes */
client = mateconf_client_get_default ();
mateconf_client_add_dir (client, BOOKMARKS_KEY, MATECONF_CLIENT_PRELOAD_NONE, NULL);
dialog->notify_id = mateconf_client_notify_add (client, BOOKMARKS_KEY,
mateconf_bookmarks_dialog_bookmarks_key_changed,
dialog,
NULL,
NULL);
g_object_unref (client);
}
void
procdialog_create_renice_dialog (ProcData *procdata)
{
ProcInfo *info = procdata->selected_process;
GtkWidget *dialog = NULL;
GtkWidget *dialog_vbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *priority_label;
GtkWidget *grid;
GtkAdjustment *renice_adj;
GtkWidget *hscale;
GtkWidget *button;
GtkWidget *icon;
gchar *text;
gchar *dialog_title;
if (renice_dialog)
return;
if (!info)
return;
dialog_title = g_strdup_printf (_("Change Priority of Process “%s” (PID: %u)"),
info->name, info->pid);
dialog = gtk_dialog_new_with_buttons (dialog_title, NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-cancel", GTK_RESPONSE_CANCEL,
NULL);
g_free (dialog_title);
renice_dialog = dialog;
gtk_window_set_resizable (GTK_WINDOW (renice_dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (renice_dialog), 5);
button = gtk_button_new_with_mnemonic (_("Change _Priority"));
gtk_widget_set_can_default (button, TRUE);
icon = gtk_image_new_from_stock ("gtk-ok", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (button), icon);
gtk_dialog_add_action_widget (GTK_DIALOG (renice_dialog), button, 100);
gtk_dialog_set_default_response (GTK_DIALOG (renice_dialog), 100);
new_nice_value = -100;
dialog_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (dialog_vbox), 2);
gtk_container_set_border_width (GTK_CONTAINER (dialog_vbox), 5);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (dialog_vbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID(grid), 12);
gtk_grid_set_row_spacing (GTK_GRID(grid), 6);
gtk_box_pack_start (GTK_BOX (vbox), grid, TRUE, TRUE, 0);
label = gtk_label_new_with_mnemonic (_("_Nice value:"));
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 2);
renice_adj = gtk_adjustment_new (info->nice, RENICE_VAL_MIN, RENICE_VAL_MAX, 1, 1, 0);
new_nice_value = 0;
hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, renice_adj);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), hscale);
gtk_scale_set_digits (GTK_SCALE (hscale), 0);
gtk_widget_set_hexpand (hscale, TRUE);
gtk_grid_attach (GTK_GRID (grid), hscale, 1, 0, 1, 1);
text = g_strdup_printf(_("(%s Priority)"), procman::get_nice_level (info->nice));
priority_label = gtk_label_new (text);
gtk_grid_attach (GTK_GRID (grid), priority_label, 1, 1, 1, 1);
g_free(text);
text = g_strconcat("<small><i><b>", _("Note:"), "</b> ",
_("The priority of a process is given by its nice value. A lower nice value corresponds to a higher priority."),
"</i></small>", NULL);
label = gtk_label_new (_(text));
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
g_free (text);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (renice_dialog_button_pressed), procdata);
g_signal_connect (G_OBJECT (renice_adj), "value_changed",
G_CALLBACK (renice_scale_changed), priority_label);
gtk_widget_show_all (dialog);
}
void
gkrellm_plugins_config_create(GtkWidget *tab_vbox)
{
GtkWidget *tabs;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *scrolled;
GtkWidget *view;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkTextIter iter;
GtkTextBuffer *buffer;
row_reference = NULL;
tabs = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(tabs), GTK_POS_TOP);
gtk_box_pack_start(GTK_BOX(tab_vbox), tabs, TRUE, TRUE, 0);
/* -- Plugins tab */
vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Plugins"));
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 2);
model = create_model();
treeview = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
g_object_unref(G_OBJECT(model));
gtk_tree_view_set_rules_hint(treeview, TRUE);
renderer = gtk_cell_renderer_toggle_new();
gtk_tree_view_insert_column_with_attributes(treeview, -1, _("Enable"),
renderer,
"active", ENABLE_COLUMN, NULL);
g_signal_connect (G_OBJECT(renderer), "toggled",
G_CALLBACK(cb_enable_plugin), model);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes (_("Plugin"),
renderer,
"text", NAME_COLUMN, NULL);
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_sort_column_id(column, NAME_COLUMN);
gtk_tree_view_column_clicked(column); /* Sort it */
/* gtk_tree_sortable_set_sort_column_id(model,
NAME_COLUMN, GTK_ORDER_ASCENDING);
*/
gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(treeview));
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(cb_tree_selection_changed), NULL);
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_START);
gtk_box_set_spacing(GTK_BOX(hbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 2);
place_button = gtk_button_new_with_label(_("Place"));
gtk_box_pack_start(GTK_BOX(hbox), place_button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(GTK_BUTTON(place_button)), "clicked",
G_CALLBACK(cb_place_button), NULL);
gtk_widget_set_sensitive(place_button, FALSE);
/* --Plugins detect log tab */
vbox = gkrellm_gtk_framed_notebook_page(tabs, _("Install Log"));
view = gkrellm_gtk_scrolled_text_view(vbox, NULL,
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
gtk_text_buffer_get_end_iter(buffer, &iter);
if (plugin_install_log)
gtk_text_buffer_insert(buffer, &iter, plugin_install_log, -1);
else
gtk_text_buffer_insert(buffer, &iter, _("No plugins found."), -1);
}
static void
mate_volume_control_preferences_init (MateVolumeControlPreferences *prefs)
{
GtkWidget *box, *label, *view;
GtkListStore *store;
GtkTreeSelection *sel;
GtkTreeViewColumn *col;
GtkCellRenderer *render;
prefs->settings = NULL;
prefs->mixer = NULL;
/* make window look cute */
gtk_window_set_title (GTK_WINDOW (prefs), _("Volume Control Preferences"));
#if !GTK_CHECK_VERSION (3, 0, 0)
gtk_dialog_set_has_separator (GTK_DIALOG (prefs), FALSE);
#endif
gtk_container_set_border_width (GTK_CONTAINER (prefs), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (prefs))), 2);
gtk_dialog_add_buttons (GTK_DIALOG (prefs),
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
/* help goes here (future) */
NULL);
/* add a treeview for all the properties */
box = gtk_vbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (box), 5);
label = gtk_label_new_with_mnemonic (_("_Select mixers to be visible:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_widget_show (label);
store = gtk_list_store_new (NUM_COLS, G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_STRING,
G_TYPE_INT);
gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (store), sort_by_page_num, NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
prefs->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (prefs->treeview), FALSE);
gtk_label_set_mnemonic_widget (GTK_LABEL(label), GTK_WIDGET (prefs->treeview));
/* viewport for lots of tracks */
view = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view),
GTK_SHADOW_IN);
gtk_widget_set_size_request (view, -1, 250);
gtk_container_add (GTK_CONTAINER (view), prefs->treeview);
gtk_box_pack_start (GTK_BOX (box), view, TRUE, TRUE, 0);
gtk_widget_show (prefs->treeview);
gtk_widget_show (view);
/* treeview internals */
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (prefs->treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_SINGLE);
render = gtk_cell_renderer_toggle_new ();
g_signal_connect (render, "toggled",
G_CALLBACK (cb_toggle), prefs);
g_signal_connect (prefs->treeview, "row-activated",
G_CALLBACK (cb_activated), prefs);
col = gtk_tree_view_column_new_with_attributes ("Active", render,
"active", COL_ACTIVE,
NULL);
gtk_tree_view_column_set_clickable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (prefs->treeview), col);
render = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Track name", render,
"text", COL_LABEL,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (prefs->treeview), col);
render = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Type", render,
"text", COL_TYPE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (prefs->treeview), col);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (prefs->treeview), COL_LABEL);
/* and show */
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (prefs))), box,
TRUE, TRUE, 0);
gtk_widget_show (box);
}
static void
show_auth_dialog(LuakitAuthData *auth_data, const char *login, const char *password)
{
GtkWidget *widget = gtk_dialog_new();
GtkWindow *window = GTK_WINDOW(widget);
GtkDialog *dialog = GTK_DIALOG(widget);
gtk_dialog_add_buttons(dialog,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
/* set dialog 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);
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);
/* build contents */
GtkWidget *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);
GtkWidget *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);
GtkWidget *main_vbox = gtk_vbox_new(FALSE, 18);
gtk_box_pack_start(GTK_BOX(hbox), main_vbox, TRUE, TRUE, 0);
SoupURI *uri = soup_message_get_uri(auth_data->msg);
gchar *msg = g_strdup_printf("A username and password are being requested by the site %s", uri->host);
GtkWidget *msg_label = gtk_label_new(msg);
g_free(msg);
gtk_misc_set_alignment(GTK_MISC(msg_label), 0.0, 0.5);
gtk_label_set_line_wrap(GTK_LABEL(msg_label), TRUE);
gtk_box_pack_start(GTK_BOX(main_vbox), GTK_WIDGET(msg_label), FALSE, FALSE, 0);
GtkWidget *vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(main_vbox), vbox, FALSE, FALSE, 0);
/* the table that holds the entries */
GtkWidget *entry_container = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
gtk_alignment_set_padding(GTK_ALIGNMENT(entry_container), 0, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), entry_container, FALSE, FALSE, 0);
GtkWidget *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(entry_container), table);
auth_data->login_entry = table_add_entry(table, 0, "Username:"******"Password:"******"Store password");
gtk_label_set_line_wrap(GTK_LABEL(gtk_bin_get_child(GTK_BIN(checkbutton))), TRUE);
gtk_box_pack_start(GTK_BOX(remember_box), checkbutton, FALSE, FALSE, 0);
auth_data->checkbutton = checkbutton;
g_signal_connect(dialog, "response", G_CALLBACK(response_callback), auth_data);
gtk_widget_show_all(widget);
}
static void
gimp_page_selector_init (GimpPageSelector *selector)
{
GimpPageSelectorPrivate *priv;
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *hbox;
GtkWidget *hbbox;
GtkWidget *button;
GtkWidget *label;
GtkWidget *combo;
selector->priv = G_TYPE_INSTANCE_GET_PRIVATE (selector,
GIMP_TYPE_PAGE_SELECTOR,
GimpPageSelectorPrivate);
priv = GIMP_PAGE_SELECTOR_GET_PRIVATE (selector);
priv->n_pages = 0;
priv->target = GIMP_PAGE_SELECTOR_TARGET_LAYERS;
gtk_orientable_set_orientation (GTK_ORIENTABLE (selector),
GTK_ORIENTATION_VERTICAL);
gtk_box_set_spacing (GTK_BOX (selector), 12);
/* Pages */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_box_pack_start (GTK_BOX (selector), vbox, TRUE, TRUE, 0);
gtk_widget_show (vbox);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
gtk_widget_show (sw);
priv->store = gtk_list_store_new (4,
G_TYPE_INT,
GDK_TYPE_PIXBUF,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
priv->view = gtk_icon_view_new_with_model (GTK_TREE_MODEL (priv->store));
gtk_icon_view_set_text_column (GTK_ICON_VIEW (priv->view),
COLUMN_LABEL);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (priv->view),
COLUMN_THUMBNAIL);
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (priv->view),
GTK_SELECTION_MULTIPLE);
gtk_container_add (GTK_CONTAINER (sw), priv->view);
gtk_widget_show (priv->view);
g_signal_connect (priv->view, "selection-changed",
G_CALLBACK (gimp_page_selector_selection_changed),
selector);
g_signal_connect (priv->view, "item-activated",
G_CALLBACK (gimp_page_selector_item_activated),
selector);
/* Count label */
priv->count_label = gtk_label_new (_("Nothing selected"));
gtk_misc_set_alignment (GTK_MISC (priv->count_label), 0.0, 0.5);
gimp_label_set_attributes (GTK_LABEL (priv->count_label),
PANGO_ATTR_STYLE, PANGO_STYLE_ITALIC,
-1);
gtk_box_pack_start (GTK_BOX (vbox), priv->count_label, FALSE, FALSE, 0);
gtk_widget_show (priv->count_label);
/* Select all button & range entry */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (selector), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
hbbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (hbox), hbbox, FALSE, FALSE, 0);
gtk_widget_show (hbbox);
button = gtk_button_new_with_mnemonic (_("Select _All"));
gtk_box_pack_start (GTK_BOX (hbbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gimp_page_selector_select_all),
selector);
priv->range_entry = gtk_entry_new ();
gtk_widget_set_size_request (priv->range_entry, 80, -1);
gtk_box_pack_end (GTK_BOX (hbox), priv->range_entry, TRUE, TRUE, 0);
gtk_widget_show (priv->range_entry);
g_signal_connect (priv->range_entry, "focus-out-event",
G_CALLBACK (gimp_page_selector_range_focus_out),
selector);
g_signal_connect (priv->range_entry, "activate",
G_CALLBACK (gimp_page_selector_range_activate),
selector);
label = gtk_label_new_with_mnemonic (_("Select _range:"));
gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->range_entry);
/* Target combo */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (selector), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
label = gtk_label_new_with_mnemonic (_("Open _pages as"));
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
combo = gimp_prop_enum_combo_box_new (G_OBJECT (selector), "target", -1, -1);
gtk_box_pack_start (GTK_BOX (hbox), combo, FALSE, FALSE, 0);
gtk_widget_show (combo);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), combo);
priv->default_thumbnail =
gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
"text-x-generic", 32, 0, NULL);
}
void
show_hide_advanced (GtkWidget *button, gpointer data)
{
GtkWidget *parent, *tmp;
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *check_login;
GtkWidget *check_presenv;
GksuContext *context = (GksuContext*)data;
gint response;
parent = gtk_widget_get_parent (button);
while ((tmp = gtk_widget_get_parent (parent)) != NULL)
parent = tmp;
dialog = gtk_dialog_new_with_buttons (_("Advanced options"),
GTK_WINDOW(parent),
GTK_DIALOG_MODAL,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
gtk_dialog_set_has_separator (GTK_DIALOG(dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER(dialog), 4);
/* vbox points to the dialog's vbox */
vbox = GTK_DIALOG(dialog)->vbox;
gtk_box_set_spacing (GTK_BOX(vbox), 3);
/* label */
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL(label),
_("<b>Options to use when changing user</b>"));
gtk_box_pack_start (GTK_BOX(vbox), label, TRUE, TRUE, 5);
gtk_widget_show (label);
/* login shell? (--login) */
check_login = gtk_check_button_new_with_mnemonic (_("_login shell"));
if (gksu_context_get_login_shell (context) == TRUE) /* window may have been opened before */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check_login), TRUE);
gtk_box_pack_start (GTK_BOX(vbox), check_login, TRUE, TRUE, 0);
gtk_widget_show (check_login);
/* preserve environment (--preserve-env) */
check_presenv =
gtk_check_button_new_with_mnemonic (_("_preserve environment"));
if (gksu_context_get_keep_env (context) == TRUE)
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(check_presenv), TRUE);
gtk_box_pack_start (GTK_BOX(vbox), check_presenv, TRUE, TRUE, 0);
gtk_widget_show (check_presenv);
response = gtk_dialog_run (GTK_DIALOG(dialog));
if (response == GTK_RESPONSE_NONE)
return;
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check_login)))
gksu_context_set_login_shell (context, TRUE);
else
gksu_context_set_login_shell (context, FALSE);
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(check_presenv)))
gksu_context_set_keep_env (context, TRUE);
else
gksu_context_set_keep_env (context, FALSE);
gtk_widget_destroy (dialog);
}
static void
on_game_scores (GtkMenuItem * m, gpointer data)
{
GtkWidget *grid, *grid2, *icon;
if (scorebox != NULL) {
gtk_window_present (GTK_WINDOW (scorebox));
return;
}
scorebox = gtk_dialog_new_with_buttons (_("Scores"),
GTK_WINDOW (app),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE, NULL);
gtk_window_set_resizable (GTK_WINDOW (scorebox), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (scorebox), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (scorebox))), 2);
g_signal_connect (scorebox, "destroy",
G_CALLBACK (gtk_widget_destroyed), &scorebox);
grid = gtk_grid_new ();
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
gtk_container_set_border_width (GTK_CONTAINER (grid), 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (scorebox))),
grid, TRUE, TRUE, 0);
icon = gtk_image_new_from_icon_name ("gnect", 48);
gtk_container_add (GTK_CONTAINER (grid), icon);
grid2 = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (grid), grid2);
gtk_grid_set_column_spacing (GTK_GRID (grid2), 6);
label_name[PLAYER1] = gtk_label_new (NULL);
gtk_grid_attach (GTK_GRID (grid2), label_name[PLAYER1], 0, 0, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label_name[PLAYER1]), 0, 0.5);
label_score[PLAYER1] = gtk_label_new (NULL);
gtk_grid_attach (GTK_GRID (grid2), label_score[PLAYER1], 1, 0, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label_score[PLAYER1]), 1, 0.5);
label_name[PLAYER2] = gtk_label_new (NULL);
gtk_grid_attach (GTK_GRID (grid2), label_name[PLAYER2], 0, 1, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label_name[PLAYER2]), 0, 0.5);
label_score[PLAYER2] = gtk_label_new (NULL);
gtk_grid_attach (GTK_GRID (grid2), label_score[PLAYER2], 1, 1, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label_score[PLAYER2]), 1, 0.5);
label_name[NOBODY] = gtk_label_new (_("Drawn:"));
gtk_grid_attach (GTK_GRID (grid2), label_name[NOBODY], 0, 2, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label_name[NOBODY]), 0, 0.5);
label_score[NOBODY] = gtk_label_new (NULL);
gtk_grid_attach (GTK_GRID (grid2), label_score[NOBODY], 1, 2, 1, 1);
gtk_misc_set_alignment (GTK_MISC (label_score[NOBODY]), 1, 0.5);
g_signal_connect (GTK_DIALOG (scorebox), "response",
G_CALLBACK (on_dialog_close), NULL);
gtk_widget_show_all (scorebox);
scorebox_update ();
}
static void games_scores_dialog_init (GamesScoresDialog *self)
{
GtkWidget *vbox;
GtkWidget *scroll;
GtkWidget *listview;
GtkTreeViewColumn *column;
GtkTreeViewColumn *timecolumn;
GtkCellRenderer *renderer;
GtkCellRenderer *timerenderer;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GAMES_TYPE_SCORES_DIALOG,
GamesScoresDialogPrivate);
self->priv->style = GAMES_SCORES_STYLE_PLAIN_DESCENDING;
/* These two hashes are the reverse of each other. As an optimisation
* they share the same set of strings (as keys in the first case and
* as data in the second). The first hash is responsible for
* deallocating the memory for the strings. These two are only
* valid as a pair. */
self->priv->categories = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, NULL);
self->priv->catindices = g_hash_table_new (g_direct_hash, g_direct_equal);
self->priv->catcounter = 0;
self->priv->hilight = 0;
gtk_container_set_border_width (GTK_CONTAINER (self), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), 2);
g_signal_connect (G_OBJECT (self), "show",
G_CALLBACK (games_scores_dialog_show), NULL);
g_signal_connect (G_OBJECT (self), "hide",
G_CALLBACK (games_scores_dialog_hide), NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))),
vbox, TRUE, TRUE, 0);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scroll, 200, 265);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
GTK_SHADOW_ETCHED_IN);
gtk_box_pack_end (GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
self->priv->message = gtk_label_new ("");
gtk_label_set_use_markup (GTK_LABEL (self->priv->message), TRUE);
gtk_label_set_justify (GTK_LABEL (self->priv->message),
GTK_JUSTIFY_CENTER);
gtk_box_pack_start (GTK_BOX (vbox), self->priv->message, FALSE, FALSE, 0);
self->priv->hdiv = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), self->priv->hdiv, FALSE, FALSE, 0);
self->priv->catbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox), self->priv->catbar, FALSE, FALSE, 0);
self->priv->label = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (self->priv->label), TRUE);
gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->label,
FALSE, FALSE, 0);
self->priv->combo = gtk_combo_box_text_new ();
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (self->priv->combo), FALSE);
gtk_box_pack_start (GTK_BOX (self->priv->catbar),
self->priv->combo, TRUE, TRUE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (self->priv->label), self->priv->combo);
g_signal_connect (G_OBJECT (self->priv->combo), "changed",
G_CALLBACK (games_scores_dialog_change_category), self);
self->priv->list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
listview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->list));
self->priv->treeview = GTK_TREE_VIEW (listview);
timerenderer = gtk_cell_renderer_text_new ();
timecolumn = gtk_tree_view_column_new_with_attributes (/* Score dialog column header for the date the score was recorded */
_("Date"),
timerenderer,
"text", 0,
NULL);
g_object_set (G_OBJECT (timerenderer), "xalign", 1.0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (listview),
GTK_TREE_VIEW_COLUMN (timecolumn));
self->priv->timecolumn = timecolumn;
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", 1, NULL);
g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (listview),
GTK_TREE_VIEW_COLUMN (column));
self->priv->column = column;
gtk_container_add (GTK_CONTAINER (scroll), listview);
games_scores_dialog_set_buttons (self, GAMES_SCORES_CLOSE_BUTTON);
gtk_window_set_destroy_with_parent (GTK_WINDOW (self), TRUE);
gtk_widget_grab_focus (self->priv->combo);
gtk_widget_show_all (vbox);
gtk_widget_hide (self->priv->hdiv);
gtk_widget_hide (self->priv->message);
}
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 ( ! key_writable (eyes_applet->applet, "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;
}
static TBEditorWidget *tb_editor_create_dialog(MidoriBrowser *parent)
{
GtkWidget *dialog, *vbox, *hbox, *vbox_buttons, *button_add, *button_remove;
GtkWidget *swin_available, *swin_used, *tree_available, *tree_used, *label;
GtkCellRenderer *text_renderer, *icon_renderer;
GtkTreeViewColumn *column;
TBEditorWidget *tbw = g_new(TBEditorWidget, 1);
dialog = gtk_dialog_new_with_buttons(_("Customize Toolbar"),
GTK_WINDOW(parent),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
vbox = (GTK_DIALOG(dialog))->vbox;
gtk_box_set_spacing(GTK_BOX(vbox), 6);
gtk_widget_set_name(dialog, "GeanyDialog");
gtk_window_set_default_size(GTK_WINDOW(dialog), -1, 400);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
tbw->store_available = gtk_list_store_new(TB_EDITOR_COLS_MAX,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
tbw->store_used = gtk_list_store_new(TB_EDITOR_COLS_MAX,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
label = gtk_label_new(
_("Select items to be displayed on the toolbar. Items can be reodered by drag and drop."));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
tree_available = gtk_tree_view_new();
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_available), GTK_TREE_MODEL(tbw->store_available));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_available), TRUE);
gtk_tree_sortable_set_sort_column_id(
GTK_TREE_SORTABLE(tbw->store_available), TB_EDITOR_COL_LABEL, GTK_SORT_ASCENDING);
icon_renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(
NULL, icon_renderer, "stock-id", TB_EDITOR_COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column);
text_renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Available Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_available), column);
swin_available = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_available),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_available), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(swin_available), tree_available);
tree_used = gtk_tree_view_new();
gtk_tree_view_set_model(GTK_TREE_VIEW(tree_used), GTK_TREE_MODEL(tbw->store_used));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree_used), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(tree_used), TRUE);
icon_renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(
NULL, icon_renderer, "stock-id", TB_EDITOR_COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column);
text_renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Displayed Items"), text_renderer, "text", TB_EDITOR_COL_LABEL, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_used), column);
swin_used = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin_used),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin_used), GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(swin_used), tree_used);
/* drag'n'drop */
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_available), GDK_BUTTON1_MASK,
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_available),
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
g_signal_connect(tree_available, "drag-data-get",
G_CALLBACK(tb_editor_drag_data_get_cb), tbw);
g_signal_connect(tree_available, "drag-data-received",
G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw);
g_signal_connect(tree_available, "drag-motion",
G_CALLBACK(tb_editor_drag_motion_cb), tbw);
gtk_tree_view_enable_model_drag_source(GTK_TREE_VIEW(tree_used), GDK_BUTTON1_MASK,
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest(GTK_TREE_VIEW(tree_used),
tb_editor_dnd_targets, tb_editor_dnd_targets_len, GDK_ACTION_MOVE);
g_signal_connect(tree_used, "drag-data-get",
G_CALLBACK(tb_editor_drag_data_get_cb), tbw);
g_signal_connect(tree_used, "drag-data-received",
G_CALLBACK(tb_editor_drag_data_rcvd_cb), tbw);
g_signal_connect(tree_used, "drag-motion",
G_CALLBACK(tb_editor_drag_motion_cb), tbw);
button_add = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(button_add),
gtk_image_new_from_stock(GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON));
button_remove = gtk_button_new();
g_signal_connect(button_add, "clicked", G_CALLBACK(tb_editor_btn_add_clicked_cb), tbw);
gtk_button_set_image(GTK_BUTTON(button_remove),
gtk_image_new_from_stock(GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON));
g_signal_connect(button_remove, "clicked", G_CALLBACK(tb_editor_btn_remove_clicked_cb), tbw);
vbox_buttons = gtk_vbox_new(FALSE, 6);
/* FIXME this is a little hack'ish, any better ideas? */
gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), button_add, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), button_remove, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_buttons), gtk_label_new(""), TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(hbox), swin_available, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox_buttons, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), swin_used, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
gtk_widget_show_all(vbox);
g_object_unref(tbw->store_available);
g_object_unref(tbw->store_used);
tbw->dialog = dialog;
tbw->tree_available = GTK_TREE_VIEW(tree_available);
tbw->tree_used = GTK_TREE_VIEW(tree_used);
tbw->last_drag_path = NULL;
return tbw;
}
unsigned char leverage_data_dialog (void)
{
struct flag_info *finfo;
GtkWidget *dialog, *tmp, *button, *vbox, *hbox;
GtkWidget *internal_vbox;
unsigned char flag = SAVE_LEVERAGE | SAVE_INFLUENCE | SAVE_DFFITS;
finfo = malloc(sizeof *finfo);
if (finfo == NULL) return 0;
dialog = gtk_dialog_new();
finfo->dialog = dialog;
finfo->flag = &flag;
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
hbox = gtk_dialog_get_action_area(GTK_DIALOG(dialog));
gtk_window_set_title(GTK_WINDOW(dialog), _("gretl: save data"));
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);
gtk_box_set_spacing(GTK_BOX(vbox), 5);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE);
g_signal_connect(G_OBJECT(dialog), "destroy",
G_CALLBACK(destroy_save_dialog), finfo);
internal_vbox = gtk_vbox_new(FALSE, 5);
hbox = gtk_hbox_new(FALSE, 5);
tmp = gtk_label_new(_("Variables to save:"));
gtk_box_pack_start(GTK_BOX(hbox), tmp, TRUE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(internal_vbox), hbox, TRUE, TRUE, 5);
/* Leverage */
button = gtk_check_button_new_with_label(_("leverage"));
gtk_box_pack_start(GTK_BOX(internal_vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(update_save_flag), finfo);
finfo->levcheck = button;
/* Influence */
button = gtk_check_button_new_with_label(_("influence"));
gtk_box_pack_start(GTK_BOX(internal_vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(update_save_flag), finfo);
finfo->infcheck = button;
/* DFFITS */
button = gtk_check_button_new_with_label(_("DFFITS"));
gtk_box_pack_start(GTK_BOX(internal_vbox), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (button), TRUE);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(update_save_flag), finfo);
finfo->dffcheck = button;
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), internal_vbox, TRUE, TRUE, 5);
gtk_widget_show(internal_vbox);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);
hbox = gtk_dialog_get_action_area(GTK_DIALOG(dialog));
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 10);
/* Cancel button */
tmp = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_container_add(GTK_CONTAINER(hbox), tmp);
g_signal_connect(G_OBJECT(tmp), "clicked",
G_CALLBACK(cancel_set_flag), finfo);
/* "OK" button */
tmp = gtk_button_new_from_stock(GTK_STOCK_OK);
gtk_container_add(GTK_CONTAINER(hbox), tmp);
g_signal_connect(G_OBJECT(tmp), "clicked",
G_CALLBACK(save_dialog_finalize), finfo);
gtk_widget_set_can_default(tmp, TRUE);
gtk_widget_grab_default(tmp);
gtk_widget_show_all(dialog);
gtk_main();
return flag;
}
GtkWidget*
create_windowEditHabit (void)
{
GtkWidget *windowEditHabit;
GtkWidget *vboxHabit;
GtkWidget *vbox6;
GtkWidget *hbox4;
GtkWidget *label12;
GtkWidget *entryHabitName;
GtkWidget *frameDate;
GtkWidget *vboxQuittime;
GtkWidget *hboxQuitDatePart;
GtkWidget *labelDay;
GtkWidget *entryDay;
GtkWidget *labelMonth;
GtkWidget *entryMonth;
GtkWidget *labelYear;
GtkWidget *entryYear;
GtkWidget *vseparator1;
GtkWidget *labelHour;
GtkWidget *entryHour;
GtkWidget *labelMinute;
GtkWidget *entryMinute;
GtkWidget *labelDate;
GtkWidget *frameHabit;
GtkWidget *tableHabitDetails;
GtkWidget *labelUnitsPerPack;
GtkWidget *labelPricePerPack;
GtkWidget *entryUnitsPerPack;
GtkWidget *entryPricePerPack;
GtkWidget *entryUnitsPerDay;
GtkWidget *labelUnitsPerDay;
GtkWidget *labelDetails;
GtkWidget *hbuttonbox4;
GtkWidget *buttonCancel;
GtkWidget *buttonApply;
windowEditHabit = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (windowEditHabit, "windowEditHabit");
gtk_window_set_title (GTK_WINDOW (windowEditHabit), "Habit");
gtk_window_set_modal (GTK_WINDOW (windowEditHabit), TRUE);
gtk_window_set_resizable (GTK_WINDOW (windowEditHabit), FALSE);
vboxHabit = gtk_vbox_new (FALSE, 5);
gtk_widget_set_name (vboxHabit, "vboxHabit");
gtk_widget_show (vboxHabit);
gtk_container_add (GTK_CONTAINER (windowEditHabit), vboxHabit);
gtk_container_set_border_width (GTK_CONTAINER (vboxHabit), 3);
vbox6 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox6, "vbox6");
gtk_widget_show (vbox6);
gtk_box_pack_start (GTK_BOX (vboxHabit), vbox6, TRUE, TRUE, 0);
hbox4 = gtk_hbox_new (FALSE, 5);
gtk_widget_set_name (hbox4, "hbox4");
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (vbox6), hbox4, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox4), 3);
label12 = gtk_label_new ("Name of this nasty habit");
gtk_widget_set_name (label12, "label12");
gtk_widget_show (label12);
gtk_box_pack_start (GTK_BOX (hbox4), label12, FALSE, FALSE, 0);
entryHabitName = gtk_entry_new ();
gtk_widget_set_name (entryHabitName, "entryHabitName");
gtk_widget_show (entryHabitName);
gtk_box_pack_start (GTK_BOX (hbox4), entryHabitName, FALSE, FALSE, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryHabitName), 20);
gtk_entry_set_width_chars (GTK_ENTRY (entryHabitName), 21);
frameDate = gtk_frame_new (NULL);
gtk_widget_set_name (frameDate, "frameDate");
gtk_widget_show (frameDate);
gtk_box_pack_start (GTK_BOX (vbox6), frameDate, TRUE, TRUE, 0);
vboxQuittime = gtk_vbox_new (FALSE, 3);
gtk_widget_set_name (vboxQuittime, "vboxQuittime");
gtk_widget_show (vboxQuittime);
gtk_container_add (GTK_CONTAINER (frameDate), vboxQuittime);
gtk_container_set_border_width (GTK_CONTAINER (vboxQuittime), 5);
hboxQuitDatePart = gtk_hbox_new (FALSE, 5);
gtk_widget_set_name (hboxQuitDatePart, "hboxQuitDatePart");
gtk_widget_show (hboxQuitDatePart);
gtk_box_pack_start (GTK_BOX (vboxQuittime), hboxQuitDatePart, TRUE, TRUE, 0);
labelDay = gtk_label_new ("Day");
gtk_widget_set_name (labelDay, "labelDay");
gtk_widget_show (labelDay);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), labelDay, FALSE, FALSE, 0);
entryDay = gtk_entry_new ();
gtk_widget_set_name (entryDay, "entryDay");
gtk_widget_show (entryDay);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), entryDay, FALSE, FALSE, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryDay), 2);
gtk_entry_set_width_chars (GTK_ENTRY (entryDay), 3);
labelMonth = gtk_label_new ("Month");
gtk_widget_set_name (labelMonth, "labelMonth");
gtk_widget_show (labelMonth);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), labelMonth, FALSE, FALSE, 0);
entryMonth = gtk_entry_new ();
gtk_widget_set_name (entryMonth, "entryMonth");
gtk_widget_show (entryMonth);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), entryMonth, FALSE, FALSE, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryMonth), 2);
gtk_entry_set_width_chars (GTK_ENTRY (entryMonth), 3);
labelYear = gtk_label_new ("Year");
gtk_widget_set_name (labelYear, "labelYear");
gtk_widget_show (labelYear);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), labelYear, FALSE, FALSE, 0);
entryYear = gtk_entry_new ();
gtk_widget_set_name (entryYear, "entryYear");
gtk_widget_show (entryYear);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), entryYear, FALSE, FALSE, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryYear), 4);
gtk_entry_set_width_chars (GTK_ENTRY (entryYear), 5);
vseparator1 = gtk_vseparator_new ();
gtk_widget_set_name (vseparator1, "vseparator1");
gtk_widget_show (vseparator1);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), vseparator1, TRUE, TRUE, 0);
labelHour = gtk_label_new ("Hour");
gtk_widget_set_name (labelHour, "labelHour");
gtk_widget_show (labelHour);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), labelHour, FALSE, FALSE, 0);
entryHour = gtk_entry_new ();
gtk_widget_set_name (entryHour, "entryHour");
gtk_widget_show (entryHour);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), entryHour, TRUE, TRUE, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryHour), 2);
gtk_entry_set_width_chars (GTK_ENTRY (entryHour), 3);
labelMinute = gtk_label_new ("Minute");
gtk_widget_set_name (labelMinute, "labelMinute");
gtk_widget_show (labelMinute);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), labelMinute, FALSE, FALSE, 0);
entryMinute = gtk_entry_new ();
gtk_widget_set_name (entryMinute, "entryMinute");
gtk_widget_show (entryMinute);
gtk_box_pack_start (GTK_BOX (hboxQuitDatePart), entryMinute, TRUE, TRUE, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryMinute), 2);
gtk_entry_set_width_chars (GTK_ENTRY (entryMinute), 3);
labelDate = gtk_label_new ("<b> Quit date </b>");
gtk_widget_set_name (labelDate, "labelDate");
gtk_widget_show (labelDate);
gtk_frame_set_label_widget (GTK_FRAME (frameDate), labelDate);
gtk_label_set_use_markup (GTK_LABEL (labelDate), TRUE);
frameHabit = gtk_frame_new (NULL);
gtk_widget_set_name (frameHabit, "frameHabit");
gtk_widget_show (frameHabit);
gtk_box_pack_start (GTK_BOX (vbox6), frameHabit, TRUE, TRUE, 0);
tableHabitDetails = gtk_table_new (3, 2, FALSE);
gtk_widget_set_name (tableHabitDetails, "tableHabitDetails");
gtk_widget_show (tableHabitDetails);
gtk_container_add (GTK_CONTAINER (frameHabit), tableHabitDetails);
gtk_container_set_border_width (GTK_CONTAINER (tableHabitDetails), 5);
gtk_table_set_row_spacings (GTK_TABLE (tableHabitDetails), 2);
gtk_table_set_col_spacings (GTK_TABLE (tableHabitDetails), 3);
labelUnitsPerPack = gtk_label_new ("Units per pack");
gtk_widget_set_name (labelUnitsPerPack, "labelUnitsPerPack");
gtk_widget_show (labelUnitsPerPack);
gtk_table_attach (GTK_TABLE (tableHabitDetails), labelUnitsPerPack, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelUnitsPerPack), 0, 0.5);
labelPricePerPack = gtk_label_new ("Price per pack");
gtk_widget_set_name (labelPricePerPack, "labelPricePerPack");
gtk_widget_show (labelPricePerPack);
gtk_table_attach (GTK_TABLE (tableHabitDetails), labelPricePerPack, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelPricePerPack), 0, 0.5);
entryUnitsPerPack = gtk_entry_new ();
gtk_widget_set_name (entryUnitsPerPack, "entryUnitsPerPack");
gtk_widget_show (entryUnitsPerPack);
gtk_table_attach (GTK_TABLE (tableHabitDetails), entryUnitsPerPack, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK),
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryUnitsPerPack), 5);
gtk_entry_set_width_chars (GTK_ENTRY (entryUnitsPerPack), 6);
entryPricePerPack = gtk_entry_new ();
gtk_widget_set_name (entryPricePerPack, "entryPricePerPack");
gtk_widget_show (entryPricePerPack);
gtk_table_attach (GTK_TABLE (tableHabitDetails), entryPricePerPack, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK),
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryPricePerPack), 5);
gtk_entry_set_width_chars (GTK_ENTRY (entryPricePerPack), 6);
entryUnitsPerDay = gtk_entry_new ();
gtk_widget_set_name (entryUnitsPerDay, "entryUnitsPerDay");
gtk_widget_show (entryUnitsPerDay);
gtk_table_attach (GTK_TABLE (tableHabitDetails), entryUnitsPerDay, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK),
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryUnitsPerDay), 5);
gtk_entry_set_width_chars (GTK_ENTRY (entryUnitsPerDay), 6);
labelUnitsPerDay = gtk_label_new ("Units used per day");
gtk_widget_set_name (labelUnitsPerDay, "labelUnitsPerDay");
gtk_widget_show (labelUnitsPerDay);
gtk_table_attach (GTK_TABLE (tableHabitDetails), labelUnitsPerDay, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_SHRINK | GTK_FILL), 0, 0);
gtk_misc_set_alignment (GTK_MISC (labelUnitsPerDay), 0, 0.5);
labelDetails = gtk_label_new ("<b> Habit details </b>");
gtk_widget_set_name (labelDetails, "labelDetails");
gtk_widget_show (labelDetails);
gtk_frame_set_label_widget (GTK_FRAME (frameHabit), labelDetails);
gtk_label_set_use_markup (GTK_LABEL (labelDetails), TRUE);
hbuttonbox4 = gtk_hbutton_box_new ();
gtk_widget_set_name (hbuttonbox4, "hbuttonbox4");
gtk_widget_show (hbuttonbox4);
gtk_box_pack_start (GTK_BOX (vboxHabit), hbuttonbox4, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox4), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonbox4), 5);
buttonCancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_set_name (buttonCancel, "buttonCancel");
gtk_widget_show (buttonCancel);
gtk_container_add (GTK_CONTAINER (hbuttonbox4), buttonCancel);
GTK_WIDGET_SET_FLAGS (buttonCancel, GTK_CAN_DEFAULT);
buttonApply = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_set_name (buttonApply, "buttonApply");
gtk_widget_show (buttonApply);
gtk_container_add (GTK_CONTAINER (hbuttonbox4), buttonApply);
GTK_WIDGET_SET_FLAGS (buttonApply, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (windowEditHabit, windowEditHabit, "windowEditHabit");
GLADE_HOOKUP_OBJECT (windowEditHabit, vboxHabit, "vboxHabit");
GLADE_HOOKUP_OBJECT (windowEditHabit, vbox6, "vbox6");
GLADE_HOOKUP_OBJECT (windowEditHabit, hbox4, "hbox4");
GLADE_HOOKUP_OBJECT (windowEditHabit, label12, "label12");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryHabitName, "entryHabitName");
GLADE_HOOKUP_OBJECT (windowEditHabit, frameDate, "frameDate");
GLADE_HOOKUP_OBJECT (windowEditHabit, vboxQuittime, "vboxQuittime");
GLADE_HOOKUP_OBJECT (windowEditHabit, hboxQuitDatePart, "hboxQuitDatePart");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelDay, "labelDay");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryDay, "entryDay");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelMonth, "labelMonth");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryMonth, "entryMonth");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelYear, "labelYear");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryYear, "entryYear");
GLADE_HOOKUP_OBJECT (windowEditHabit, vseparator1, "vseparator1");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelHour, "labelHour");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryHour, "entryHour");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelMinute, "labelMinute");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryMinute, "entryMinute");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelDate, "labelDate");
GLADE_HOOKUP_OBJECT (windowEditHabit, frameHabit, "frameHabit");
GLADE_HOOKUP_OBJECT (windowEditHabit, tableHabitDetails, "tableHabitDetails");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelUnitsPerPack, "labelUnitsPerPack");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelPricePerPack, "labelPricePerPack");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryUnitsPerPack, "entryUnitsPerPack");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryPricePerPack, "entryPricePerPack");
GLADE_HOOKUP_OBJECT (windowEditHabit, entryUnitsPerDay, "entryUnitsPerDay");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelUnitsPerDay, "labelUnitsPerDay");
GLADE_HOOKUP_OBJECT (windowEditHabit, labelDetails, "labelDetails");
GLADE_HOOKUP_OBJECT (windowEditHabit, hbuttonbox4, "hbuttonbox4");
GLADE_HOOKUP_OBJECT (windowEditHabit, buttonCancel, "buttonCancel");
GLADE_HOOKUP_OBJECT (windowEditHabit, buttonApply, "buttonApply");
return windowEditHabit;
}
static void create_window (void)
{
jump_to_track_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(jump_to_track_win),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_title(GTK_WINDOW(jump_to_track_win), _("Jump to Song"));
g_signal_connect (jump_to_track_win, "key_press_event", (GCallback) keypress_cb, NULL);
g_signal_connect (jump_to_track_win, "delete-event", (GCallback) delete_cb, NULL);
gtk_container_set_border_width(GTK_CONTAINER(jump_to_track_win), 10);
gtk_window_set_default_size(GTK_WINDOW(jump_to_track_win), 600, 500);
GtkWidget * vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add(GTK_CONTAINER(jump_to_track_win), vbox);
treeview = mlpgui_list_new (& callbacks, NULL, 0);
gtk_tree_view_set_headers_visible ((GtkTreeView *) treeview, FALSE);
mlpgui_list_add_column (treeview, NULL, 0, G_TYPE_INT, 7);
mlpgui_list_add_column (treeview, NULL, 1, G_TYPE_STRING, -1);
g_signal_connect (gtk_tree_view_get_selection ((GtkTreeView *) treeview),
"changed", (GCallback) selection_changed, NULL);
g_signal_connect (treeview, "row-activated", (GCallback) do_jump, NULL);
GtkWidget * hbox = gtk_hbox_new (FALSE, 3);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
/* filter box */
GtkWidget * search_label = gtk_label_new (_("Filter: "));
gtk_label_set_markup_with_mnemonic(GTK_LABEL(search_label), _("_Filter:"));
gtk_box_pack_start(GTK_BOX(hbox), search_label, FALSE, FALSE, 0);
filter_entry = gtk_entry_new ();
gtk_label_set_mnemonic_widget ((GtkLabel *) search_label, filter_entry);
g_signal_connect (filter_entry, "changed", (GCallback) fill_list, NULL);
gtk_entry_set_activates_default ((GtkEntry *) filter_entry, TRUE);
gtk_box_pack_start ((GtkBox *) hbox, filter_entry, TRUE, TRUE, 3);
/* remember text entry */
GtkWidget * toggle2 = gtk_check_button_new_with_label (_("Remember"));
gtk_toggle_button_set_active ((GtkToggleButton *) toggle2, mlp_get_bool
("mlpgui", "remember_jtf_entry"));
gtk_box_pack_start(GTK_BOX(hbox), toggle2, FALSE, FALSE, 0);
g_signal_connect (toggle2, "clicked", (GCallback) toggle_button_cb, "remember_jtf_entry");
/* clear button */
GtkWidget * rescan = gtk_button_new_with_mnemonic (_("Clea_r"));
gtk_button_set_image ((GtkButton *) rescan, gtk_image_new_from_stock
(GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start(GTK_BOX(hbox), rescan, FALSE, FALSE, 0);
g_signal_connect (rescan, "clicked", (GCallback) clear_cb, NULL);
GtkWidget * scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add(GTK_CONTAINER(scrollwin), treeview);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrollwin),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), scrollwin, TRUE, TRUE, 0);
GtkWidget * bbox = gtk_hbutton_box_new ();
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 4);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
/* close dialog toggle */
GtkWidget * toggle = gtk_check_button_new_with_label(_("Close on Jump"));
gtk_toggle_button_set_active ((GtkToggleButton *) toggle, mlp_get_bool
("mlpgui", "close_jtf_dialog"));
gtk_box_pack_start(GTK_BOX(bbox), toggle, FALSE, FALSE, 0);
g_signal_connect (toggle, "clicked", (GCallback) toggle_button_cb, "close_jtf_dialog");
/* queue button */
queue_button = gtk_button_new_with_mnemonic(_("_Queue"));
gtk_button_set_image ((GtkButton *) queue_button, gtk_image_new_from_stock
(AUD_STOCK_QUEUETOGGLE, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start ((GtkBox *) bbox, queue_button, FALSE, FALSE, 0);
g_signal_connect (queue_button, "clicked", (GCallback) do_queue, NULL);
/* jump button */
GtkWidget * jump = gtk_button_new_from_stock (GTK_STOCK_JUMP_TO);
gtk_box_pack_start(GTK_BOX(bbox), jump, FALSE, FALSE, 0);
g_signal_connect (jump, "clicked", (GCallback) do_jump, NULL);
gtk_widget_set_can_default(jump, TRUE);
gtk_widget_grab_default(jump);
/* close button */
GtkWidget * close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_box_pack_start(GTK_BOX(bbox), close, FALSE, FALSE, 0);
g_signal_connect (close, "clicked", (GCallback) mlpgui_jump_to_track_hide,
NULL);
gtk_widget_set_can_default(close, TRUE);
}
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;
}
GtkWidget* ctk_xvideo_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config,
CtkEvent *ctk_event)
{
GObject *object;
CtkXVideo *ctk_xvideo;
GtkWidget *banner;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
int sync_mask;
int xv_overlay_present, xv_texture_present, xv_blitter_present;
ReturnStatus ret;
/*
* before we do anything else, determine if any of the Xv adapters
* are present
*/
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_OVERLAY_PRESENT,
&xv_overlay_present);
if (ret != NvCtrlSuccess) xv_overlay_present = FALSE;
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_TEXTURE_PRESENT,
&xv_texture_present);
if (ret != NvCtrlSuccess) xv_texture_present = FALSE;
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_BLITTER_PRESENT,
&xv_blitter_present);
if (ret != NvCtrlSuccess) xv_blitter_present = FALSE;
if (!xv_overlay_present && !xv_texture_present && !xv_blitter_present) {
return NULL;
}
/* create the XVideo widget */
object = g_object_new(CTK_TYPE_XVIDEO, NULL);
ctk_xvideo = CTK_XVIDEO(object);
ctk_xvideo->handle = handle;
ctk_xvideo->ctk_config = ctk_config;
ctk_xvideo->active_attributes = 0;
gtk_box_set_spacing(GTK_BOX(ctk_xvideo), 10);
/* Create button, but don't pack it, yet */
label = gtk_label_new("Reset Hardware Defaults");
hbox = gtk_hbox_new(FALSE, 0);
button = gtk_button_new();
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15);
gtk_container_add(GTK_CONTAINER(button), hbox);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(reset_defaults), (gpointer) ctk_xvideo);
ctk_config_set_tooltip(ctk_config, button, __reset_button_help);
/* Video film banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_XVIDEO);
gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
/* XVideo Overlay sliders */
if (xv_overlay_present) {
frame = gtk_frame_new("Video Overlay Adaptor");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->overlay_saturation =
create_slider(ctk_xvideo, vbox, button, "Saturation",
__xv_overlay_saturation_help,
NV_CTRL_ATTR_XV_OVERLAY_SATURATION,
__XV_OVERLAY_SATURATION);
ctk_xvideo->overlay_contrast =
create_slider(ctk_xvideo, vbox, button, "Contrast",
__xv_overlay_contrast_help,
NV_CTRL_ATTR_XV_OVERLAY_CONTRAST,
__XV_OVERLAY_CONTRAST);
ctk_xvideo->overlay_brightness =
create_slider(ctk_xvideo, vbox, button, "Brightness",
__xv_overlay_brightness_help,
NV_CTRL_ATTR_XV_OVERLAY_BRIGHTNESS,
__XV_OVERLAY_BRIGHTNESS);
ctk_xvideo->overlay_hue =
create_slider(ctk_xvideo, vbox, button, "Hue",
__xv_overlay_hue_help,
NV_CTRL_ATTR_XV_OVERLAY_HUE,
__XV_OVERLAY_HUE);
}
/* XVideo Texture */
if (xv_texture_present) {
frame = gtk_frame_new("Video Texture Adaptor");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->texture_sync_to_blank =
create_check_button(ctk_xvideo, vbox, button, "Sync to VBlank",
__xv_texture_sync_to_vblank_help,
NV_CTRL_ATTR_XV_TEXTURE_SYNC_TO_VBLANK,
__XV_TEXTURE_SYNC_TO_VBLANK);
ctk_xvideo->texture_brightness =
create_slider(ctk_xvideo, vbox, button, "Brightness",
__xv_texture_brightness_help,
NV_CTRL_ATTR_XV_TEXTURE_BRIGHTNESS,
__XV_TEXTURE_BRIGHTNESS);
ctk_xvideo->texture_contrast =
create_slider(ctk_xvideo, vbox, button, "Contrast",
__xv_texture_contrast_help,
NV_CTRL_ATTR_XV_TEXTURE_CONTRAST,
__XV_TEXTURE_CONTRAST);
ctk_xvideo->texture_hue =
create_slider(ctk_xvideo, vbox, button, "Hue",
__xv_texture_hue_help,
NV_CTRL_ATTR_XV_TEXTURE_HUE,
__XV_TEXTURE_HUE);
ctk_xvideo->texture_saturation =
create_slider(ctk_xvideo, vbox, button, "Saturation",
__xv_texture_saturation_help,
NV_CTRL_ATTR_XV_TEXTURE_SATURATION,
__XV_TEXTURE_SATURATION);
}
/* XVideo Blitter */
if (xv_blitter_present) {
frame = gtk_frame_new("Video Blitter Adaptor Settings");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->blitter_sync_to_blank =
create_check_button(ctk_xvideo,
vbox,
button,
"Sync to VBlank",
__xv_blitter_sync_to_vblank_help,
NV_CTRL_ATTR_XV_BLITTER_SYNC_TO_VBLANK,
__XV_BLITTER_SYNC_TO_VBLANK);
}
/* Sync to display selection */
if (xv_texture_present || xv_blitter_present) {
ret = NvCtrlGetAttribute(handle,
NV_CTRL_XV_SYNC_TO_DISPLAY,
&sync_mask);
if (ret == NvCtrlSuccess) {
int enabled;
ret = NvCtrlGetAttribute(handle,
NV_CTRL_ENABLED_DISPLAYS,
&enabled);
if (ret == NvCtrlSuccess) {
GtkWidget *radio[24], *prev_radio;
int i, n, current = -1, mask;
char *name, *type;
gchar *name_str;
frame = gtk_frame_new("Sync to this display device");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->xv_sync_to_display_button_box = vbox;
for (n=0, i = 0; i < 24; i++) {
mask = 1 << i;
if (!(enabled & mask)) continue;
/* get the name of the display device */
ret = NvCtrlGetStringDisplayAttribute(handle, mask,
NV_CTRL_STRING_DISPLAY_DEVICE_NAME,
&name);
if ((ret != NvCtrlSuccess) || (!name)) {
name = g_strdup("Unknown");
}
/* get the display device type */
type = display_device_mask_to_display_device_name(mask);
name_str = g_strdup_printf("%s (%s)", name, type);
XFree(name);
free(type);
if (n==0) {
prev_radio = NULL;
} else {
prev_radio = radio[n-1];
}
radio[n] = xv_sync_to_display_radio_button_add(ctk_xvideo,
prev_radio,
name_str,
mask, n);
g_free(name_str);
ctk_config_set_tooltip(ctk_config, radio[n],
__xv_sync_to_display_help);
if (mask == sync_mask) {
current = n;
}
n++;
ctk_xvideo->active_attributes |= __XV_SYNC_TO_DISPLAY;
}
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_XV_SYNC_TO_DISPLAY),
G_CALLBACK(xv_sync_to_display_update_received),
(gpointer) ctk_xvideo);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS),
G_CALLBACK(nv_ctrl_enabled_displays),
(gpointer) ctk_xvideo);
sensitize_radio_buttons(ctk_xvideo);
if (current != -1)
xv_sync_to_display_update_radio_buttons(ctk_xvideo, current);
}
}
}
/* Reset button */
sensitize_radio_buttons(ctk_xvideo);
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), button);
gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0);
/* finally, show the widget */
gtk_widget_show_all(GTK_WIDGET(ctk_xvideo));
return GTK_WIDGET(ctk_xvideo);
} /* ctk_xvideo_new() */
static void
nautilus_mime_application_chooser_build_ui (NautilusMimeApplicationChooser *chooser)
{
GtkWidget *box, *button;
GAppInfo *info;
gtk_container_set_border_width (GTK_CONTAINER (chooser), 8);
gtk_box_set_spacing (GTK_BOX (chooser), 0);
gtk_box_set_homogeneous (GTK_BOX (chooser), FALSE);
chooser->details->label = gtk_label_new ("");
gtk_label_set_xalign (GTK_LABEL (chooser->details->label), 0);
gtk_label_set_line_wrap (GTK_LABEL (chooser->details->label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (chooser->details->label),
PANGO_WRAP_WORD_CHAR);
gtk_box_pack_start (GTK_BOX (chooser), chooser->details->label,
FALSE, FALSE, 0);
gtk_widget_show (chooser->details->label);
chooser->details->open_with_widget = gtk_app_chooser_widget_new (chooser->details->content_type);
gtk_app_chooser_widget_set_show_default (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_app_chooser_widget_set_show_fallback (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_app_chooser_widget_set_show_other (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
TRUE);
gtk_box_pack_start (GTK_BOX (chooser), chooser->details->open_with_widget,
TRUE, TRUE, 6);
gtk_widget_show (chooser->details->open_with_widget);
box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_set_spacing (GTK_BOX (box), 6);
gtk_button_box_set_layout (GTK_BUTTON_BOX (box), GTK_BUTTONBOX_END);
gtk_box_pack_start (GTK_BOX (chooser), box, FALSE, FALSE, 6);
gtk_widget_show (box);
button = gtk_button_new_with_label (_("Reset"));
g_signal_connect (button, "clicked",
G_CALLBACK (reset_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_button_box_set_child_secondary (GTK_BUTTON_BOX (box), button, TRUE);
button = gtk_button_new_with_mnemonic (_("_Add"));
g_signal_connect (button, "clicked",
G_CALLBACK (add_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
chooser->details->add_button = button;
button = gtk_button_new_with_label (_("Set as default"));
g_signal_connect (button, "clicked",
G_CALLBACK (set_as_default_clicked_cb),
chooser);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
chooser->details->set_as_default_button = button;
/* initialize sensitivity */
info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (chooser->details->open_with_widget));
if (info != NULL) {
application_selected_cb (GTK_APP_CHOOSER_WIDGET (chooser->details->open_with_widget),
info, chooser);
g_object_unref (info);
}
g_signal_connect (chooser->details->open_with_widget,
"application-selected",
G_CALLBACK (application_selected_cb),
chooser);
g_signal_connect (chooser->details->open_with_widget,
"populate-popup",
G_CALLBACK (populate_popup_cb),
chooser);
}
void
chanlist_opengui (server *serv, int do_refresh)
{
GtkWidget *vbox, *hbox, *table, *wid, *view;
char tbuf[256];
GtkListStore *store;
if (serv->gui->chanlist_window)
{
mg_bring_tofront (serv->gui->chanlist_window);
return;
}
snprintf (tbuf, sizeof tbuf, _(DISPLAY_NAME": Channel List (%s)"),
server_get_network (serv, TRUE));
serv->gui->chanlist_pending_rows = NULL;
serv->gui->chanlist_tag = 0;
serv->gui->chanlist_flash_tag = 0;
serv->gui->chanlist_data_stored_rows = NULL;
if (!serv->gui->chanlist_minusers)
{
if (prefs.hex_gui_chanlist_minusers < 1 || prefs.hex_gui_chanlist_minusers > 999999)
{
prefs.hex_gui_chanlist_minusers = 5;
save_config();
}
serv->gui->chanlist_minusers = prefs.hex_gui_chanlist_minusers;
}
if (!serv->gui->chanlist_maxusers)
{
if (prefs.hex_gui_chanlist_maxusers < 1 || prefs.hex_gui_chanlist_maxusers > 999999)
{
prefs.hex_gui_chanlist_maxusers = 9999;
save_config();
}
serv->gui->chanlist_maxusers = prefs.hex_gui_chanlist_maxusers;
}
serv->gui->chanlist_window =
mg_create_generic_tab ("ChanList", tbuf, FALSE, TRUE, chanlist_closegui,
serv, 640, 480, &vbox, serv);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
gtk_box_set_spacing (GTK_BOX (vbox), 12);
/* make a label to store the user/channel info */
wid = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), wid, 0, 0, 0);
gtk_widget_show (wid);
serv->gui->chanlist_label = wid;
/* ============================================================= */
store = (GtkListStore *) custom_list_new();
view = gtkutil_treeview_new (vbox, GTK_TREE_MODEL (store), NULL, -1);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (view->parent),
GTK_SHADOW_IN);
serv->gui->chanlist_list = view;
g_signal_connect (G_OBJECT (view), "row_activated",
G_CALLBACK (chanlist_dclick_cb), serv);
g_signal_connect (G_OBJECT (view), "button-press-event",
G_CALLBACK (chanlist_button_cb), serv);
chanlist_add_column (view, COL_CHANNEL, 96, _("Channel"), FALSE);
chanlist_add_column (view, COL_USERS, 50, _("Users"), TRUE);
chanlist_add_column (view, COL_TOPIC, 50, _("Topic"), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
/* this is a speed up, but no horizontal scrollbar :( */
/*gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE);*/
gtk_widget_show (view);
/* ============================================================= */
table = gtk_table_new (4, 4, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 12);
gtk_table_set_row_spacings (GTK_TABLE (table), 3);
gtk_box_pack_start (GTK_BOX (vbox), table, 0, 1, 0);
gtk_widget_show (table);
wid = gtkutil_button (NULL, GTK_STOCK_FIND, 0, chanlist_search_pressed, serv,
_("_Search"));
serv->gui->chanlist_search = wid;
gtk_table_attach (GTK_TABLE (table), wid, 3, 4, 3, 4,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
wid = gtkutil_button (NULL, GTK_STOCK_REFRESH, 0, chanlist_refresh, serv,
_("_Download List"));
serv->gui->chanlist_refresh = wid;
gtk_table_attach (GTK_TABLE (table), wid, 3, 4, 2, 3,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
wid = gtkutil_button (NULL, GTK_STOCK_SAVE_AS, 0, chanlist_save, serv,
_("Save _List..."));
serv->gui->chanlist_savelist = wid;
gtk_table_attach (GTK_TABLE (table), wid, 3, 4, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
wid = gtkutil_button (NULL, GTK_STOCK_JUMP_TO, 0, chanlist_join, serv,
_("_Join Channel"));
serv->gui->chanlist_join = wid;
gtk_table_attach (GTK_TABLE (table), wid, 3, 4, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
/* ============================================================= */
wid = gtk_label_new (_("Show only:"));
gtk_misc_set_alignment (GTK_MISC (wid), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), wid, 0, 1, 3, 4,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (wid);
hbox = gtk_hbox_new (0, 0);
gtk_box_set_spacing (GTK_BOX (hbox), 9);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (hbox);
wid = gtk_label_new (_("channels with"));
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_show (wid);
wid = gtk_spin_button_new_with_range (1, 999999, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (wid),
serv->gui->chanlist_minusers);
g_signal_connect (G_OBJECT (wid), "value_changed",
G_CALLBACK (chanlist_minusers), serv);
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_show (wid);
serv->gui->chanlist_min_spin = wid;
wid = gtk_label_new (_("to"));
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_show (wid);
wid = gtk_spin_button_new_with_range (1, 999999, 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (wid),
serv->gui->chanlist_maxusers);
g_signal_connect (G_OBJECT (wid), "value_changed",
G_CALLBACK (chanlist_maxusers), serv);
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_show (wid);
wid = gtk_label_new (_("users."));
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_show (wid);
/* ============================================================= */
wid = gtk_label_new (_("Look in:"));
gtk_misc_set_alignment (GTK_MISC (wid), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), wid, 0, 1, 2, 3,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (wid);
hbox = gtk_hbox_new (0, 0);
gtk_box_set_spacing (GTK_BOX (hbox), 12);
gtk_table_attach (GTK_TABLE (table), hbox, 1, 2, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (hbox);
wid = gtk_check_button_new_with_label (_("Channel name"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wid), TRUE);
gtk_signal_connect (GTK_OBJECT (wid), "toggled",
GTK_SIGNAL_FUNC
(chanlist_match_channel_button_toggled), serv);
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_show (wid);
wid = gtk_check_button_new_with_label (_("Topic"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wid), TRUE);
gtk_signal_connect (GTK_OBJECT (wid), "toggled",
GTK_SIGNAL_FUNC (chanlist_match_topic_button_toggled),
serv);
gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0);
gtk_widget_show (wid);
serv->gui->chanlist_match_wants_channel = 1;
serv->gui->chanlist_match_wants_topic = 1;
/* ============================================================= */
wid = gtk_label_new (_("Search type:"));
gtk_misc_set_alignment (GTK_MISC (wid), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), wid, 0, 1, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (wid);
wid = gtk_combo_box_new_text ();
gtk_combo_box_append_text (GTK_COMBO_BOX (wid), _("Simple Search"));
gtk_combo_box_append_text (GTK_COMBO_BOX (wid), _("Pattern Match (Wildcards)"));
#ifndef WIN32
gtk_combo_box_append_text (GTK_COMBO_BOX (wid), _("Regular Expression"));
#endif
gtk_combo_box_set_active (GTK_COMBO_BOX (wid), serv->gui->chanlist_search_type);
gtk_table_attach (GTK_TABLE (table), wid, 1, 2, 1, 2,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
g_signal_connect (G_OBJECT (wid), "changed",
G_CALLBACK (chanlist_combo_cb), serv);
gtk_widget_show (wid);
/* ============================================================= */
wid = gtk_label_new (_("Find:"));
gtk_misc_set_alignment (GTK_MISC (wid), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), wid, 0, 1, 0, 1,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (wid);
wid = gtk_entry_new_with_max_length (255);
gtk_signal_connect (GTK_OBJECT (wid), "changed",
GTK_SIGNAL_FUNC (chanlist_find_cb), serv);
gtk_signal_connect (GTK_OBJECT (wid), "activate",
GTK_SIGNAL_FUNC (chanlist_search_pressed),
(gpointer) serv);
gtk_table_attach (GTK_TABLE (table), wid, 1, 2, 0, 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show (wid);
serv->gui->chanlist_wild = wid;
chanlist_find_cb (wid, serv);
/* ============================================================= */
wid = gtk_vseparator_new ();
gtk_table_attach (GTK_TABLE (table), wid, 2, 3, 0, 5,
GTK_SHRINK | GTK_FILL, GTK_SHRINK | GTK_FILL, 0, 0);
gtk_widget_show (wid);
g_signal_connect (G_OBJECT (serv->gui->chanlist_window), "destroy",
G_CALLBACK (chanlist_destroy_widget), serv);
/* reset the counters. */
chanlist_reset_counters (serv);
serv->gui->chanlist_tag = g_timeout_add (250, (GSourceFunc)chanlist_timeout, serv);
if (do_refresh)
chanlist_do_refresh (serv);
chanlist_update_buttons (serv);
gtk_widget_show (serv->gui->chanlist_window);
gtk_widget_grab_focus (serv->gui->chanlist_refresh);
}
static void
execute_action_mitem_cb (GtkMenuItem *menuitem, UiFormGrid *formgrid)
{
TFavoritesAction *act;
GtkWidget *dlg;
gchar *tmp;
gint response;
GtkWidget *toplevel;
act = (TFavoritesAction*) g_object_get_data (G_OBJECT (menuitem), "action");
toplevel = gtk_widget_get_toplevel ((GtkWidget*) formgrid);
tmp = g_strdup_printf (_("Set or confirm the parameters to execute\n"
"action '%s'"), act->name);
dlg = gdaui_basic_form_new_in_dialog (act->params,
(GtkWindow*) toplevel,
_("Execution of action"), tmp);
g_free (tmp);
response = gtk_dialog_run (GTK_DIALOG (dlg));
gtk_widget_destroy (dlg);
if (response == GTK_RESPONSE_ACCEPT) {
GError *lerror = NULL;
TConnection *tcnc;
tcnc = get_t_connection (formgrid);
g_assert (tcnc);
GObject *result;
result = t_connection_execute_statement (tcnc, act->stmt, act->params,
GDA_STATEMENT_MODEL_RANDOM_ACCESS, NULL,
&lerror);
if (result && GDA_IS_DATA_MODEL (result)) {
GtkWidget *dialog, *label, *fg;
GtkWidget *dcontents;
gchar *tmp;
dialog = gtk_dialog_new_with_buttons (act->name, NULL, 0,
_("_Close"), GTK_RESPONSE_CLOSE, NULL);
dcontents = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (dcontents), 5);
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_CLOSE, TRUE);
tmp = g_markup_printf_escaped ("<b>%s:</b>", act->name);
label = gtk_label_new ("");
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_box_pack_start (GTK_BOX (dcontents), label, FALSE, FALSE, 5);
fg = ui_formgrid_new (GDA_DATA_MODEL (result), TRUE,
GDAUI_DATA_PROXY_INFO_CURRENT_ROW);
ui_formgrid_set_connection (UI_FORMGRID (fg), tcnc);
ActionExecutedData *aed;
aed = g_new0 (ActionExecutedData, 1);
aed->formgrid = g_object_ref (formgrid);
aed->tcnc = g_object_ref (tcnc);
if (act->name)
aed->name = g_strdup (act->name);
aed->stmt = g_object_ref (act->stmt);
aed->params = g_object_ref (act->params);
if (GDA_IS_DATA_SELECT (result)) {
GdaStatement *stmt;
g_object_get (G_OBJECT (result), "select-stmt", &stmt, NULL);
if (stmt) {
ui_formgrid_handle_user_prefs (UI_FORMGRID (fg), NULL, stmt);
g_object_unref (stmt);
}
aed->model = g_object_ref (result);
g_signal_connect (aed->params, "holder-changed",
G_CALLBACK (action_executed_holder_changed_cb), aed);
aed->formgrid = g_object_ref (fg);
aed->formgrid->priv->autoupdate_possible = TRUE;
gtk_widget_show (aed->formgrid->priv->autoupdate_toggle);
}
gtk_box_pack_start (GTK_BOX (dcontents), fg, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 600);
gtk_widget_show_all (dialog);
g_signal_connect (dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (dialog, "close",
G_CALLBACK (gtk_widget_destroy), NULL);
g_object_set_data_full (G_OBJECT (dialog), "aed", aed,
(GDestroyNotify) action_executed_data_free);
}
else if (result) {
if (BROWSER_IS_WINDOW (toplevel)) {
browser_window_show_notice_printf (BROWSER_WINDOW (toplevel),
GTK_MESSAGE_INFO,
"ActionExecution",
"%s", _("Action successfully executed"));
}
else
ui_show_message (GTK_WINDOW (toplevel),
"%s", _("Action successfully executed"));
g_object_unref (result);
}
else {
ui_show_error (GTK_WINDOW (toplevel),
_("Error executing query: %s"),
lerror && lerror->message ? lerror->message : _("No detail"));
g_clear_error (&lerror);
}
}
}
static void
cb_place_button(GtkWidget *widget, gpointer data)
{
GtkWidget *main_vbox, *vbox, *vbox1, *vbox2, *vbox3, *hbox;
GtkWidget *button;
GtkTreeModel *model;
GtkTreePath *path;
GtkTreeIter iter;
GSList *group;
GList *list;
GkrellmMonitor *mon;
GkrellmMonprivate *mp;
gint i;
if (gkrellm_demo_mode())
return;
if (!place_plugin_window)
{
place_plugin_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(place_plugin_window), "delete_event",
G_CALLBACK(place_plugin_window_delete_event), NULL);
gtk_window_set_title(GTK_WINDOW(place_plugin_window),
_("GKrellM Place Plugin"));
gtk_window_set_wmclass(GTK_WINDOW(place_plugin_window),
"Gkrellm_conf", "Gkrellm");
main_vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(place_plugin_window), main_vbox);
place_plugin_vbox = main_vbox;
vbox = gkrellm_gtk_framed_vbox(main_vbox, NULL, 3, FALSE, 4, 3);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
vbox1 = gkrellm_gtk_framed_vbox(hbox, _("Builtin Monitors"),
3, FALSE, 4, 3);
group = NULL;
for (i = 0, list = gkrellm_monitor_list; list; list = list->next)
{
mon = (GkrellmMonitor *) list->data;
mp = mon->privat;
mon->privat->button_id = -1;
if (MONITOR_ID(mon) != MON_PLUGIN)
{
if ( !mon->name || !mon->create_monitor
|| mon == gkrellm_mon_host()
)
continue;
button = gtk_radio_button_new_with_label(group, mon->name);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(cb_place), NULL);
gtk_box_pack_start(GTK_BOX(vbox1), button, FALSE, FALSE, 0);
if (i < N_BUILTIN_MONITORS)
{
builtin_button[i] = button;
mon->privat->button_id = i++;
}
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
}
}
vbox1 = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox1, FALSE, FALSE, 0);
place_label = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(vbox1), place_label, FALSE, FALSE, 10);
vbox2 = gkrellm_gtk_framed_vbox(vbox1, _("Place Plugin"),
3, FALSE, 4, 3);
group = NULL;
vbox3 = gkrellm_gtk_framed_vbox(vbox2, NULL, 3, FALSE, 4, 3);
before_button = gtk_radio_button_new_with_label(group,
_("Before selected builtin monitor"));
g_signal_connect(G_OBJECT(before_button), "clicked",
G_CALLBACK(cb_place), NULL);
gtk_box_pack_start(GTK_BOX(vbox3), before_button, FALSE, FALSE, 0);
gkrellm_gtk_spin_button(vbox3, &gravity_spin_button, 8,
0.0, 15.0, 1, 1, 0, 50,
cb_place_spin, NULL, FALSE,
_("With gravity"));
vbox3 = gkrellm_gtk_framed_vbox(vbox2, NULL, 3, FALSE, 4, 3);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(before_button));
after_button = gtk_radio_button_new_with_label(group,
_("After selected builtin monitor"));
g_signal_connect(G_OBJECT(after_button), "clicked",
G_CALLBACK(cb_place), NULL);
gtk_box_pack_start(GTK_BOX(vbox3), after_button, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox1), hbox, FALSE, FALSE, 0);
gkrellm_gtk_button_connected(hbox, NULL, TRUE, FALSE, 0,
cb_place_default, NULL, _("Plugin Defaults"));
hbox = gtk_hbutton_box_new();
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(hbox), 5);
gtk_box_pack_end(GTK_BOX(vbox1), hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock(GTK_STOCK_OK);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(cb_close_place), NULL);
gtk_box_pack_start(GTK_BOX(hbox), button, TRUE, TRUE, 0);
gtk_widget_show_all(place_plugin_window);
}
else
gtk_window_present(GTK_WINDOW(place_plugin_window));
// gdk_window_raise(place_plugin_window->window);
if (row_reference)
{
model = gtk_tree_view_get_model(treeview);
path = gtk_tree_row_reference_get_path(row_reference);
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_get(model, &iter, MON_COLUMN, &mon, -1);
place_button_sensitivity(mon, mon->privat->enabled);
}
}
static void
gtr_preferences_dialog_init (GtrPreferencesDialog * dlg)
{
GtrPreferencesDialogPrivate *priv;
GtkWidget *action_area;
GtkWidget *profiles_toolbar;
GtkWidget *profiles_scrolled_window;
GtkBuilder *builder;
GtkBox *content_area;
GtkStyleContext *context;
gchar *root_objects[] = {
"notebook",
"adjustment1",
"adjustment2",
"adjustment3",
"model1",
NULL
};
dlg->priv = GTR_PREFERENCES_DIALOG_GET_PRIVATE (dlg);
priv = dlg->priv;
priv->ui_settings = g_settings_new ("org.gnome.gtranslator.preferences.ui");
priv->editor_settings = g_settings_new ("org.gnome.gtranslator.preferences.editor");
priv->files_settings = g_settings_new ("org.gnome.gtranslator.preferences.files");
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_window_set_title (GTK_WINDOW (dlg), _("Gtranslator Preferences"));
gtk_window_set_resizable (GTK_WINDOW (dlg), FALSE);
gtk_window_set_destroy_with_parent (GTK_WINDOW (dlg), TRUE);
action_area = gtk_dialog_get_action_area (GTK_DIALOG (dlg));
content_area = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg)));
/* HIG defaults */
gtk_container_set_border_width (GTK_CONTAINER (dlg), 5);
gtk_box_set_spacing (content_area, 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
gtk_box_set_spacing (GTK_BOX (action_area), 4);
g_signal_connect (dlg,
"response", G_CALLBACK (dialog_response_handler), NULL);
builder = gtk_builder_new ();
gtk_builder_add_objects_from_resource (builder, "/org/gnome/gtranslator/ui/gtr-preferences-dialog.ui",
root_objects, NULL);
priv->notebook = GTK_WIDGET (gtk_builder_get_object (builder, "notebook"));
g_object_ref (priv->notebook);
priv->warn_if_contains_fuzzy_checkbutton = GTK_WIDGET (gtk_builder_get_object (builder, "warn_if_fuzzy_checkbutton"));
priv->autosave_checkbutton = GTK_WIDGET (gtk_builder_get_object (builder, "autosave_checkbutton"));
priv->autosave_interval_spinbutton = GTK_WIDGET (gtk_builder_get_object (builder, "autosave_interval_spinbutton"));
priv->autosave_grid = GTK_WIDGET (gtk_builder_get_object (builder, "autosave_grid"));
priv->create_backup_checkbutton = GTK_WIDGET (gtk_builder_get_object (builder, "create_backup_checkbutton"));
priv->highlight_syntax_checkbutton = GTK_WIDGET (gtk_builder_get_object (builder, "highlight_checkbutton"));
priv->visible_whitespace_checkbutton = GTK_WIDGET (gtk_builder_get_object (builder, "visible_whitespace_checkbutton"));
priv->use_custom_font_checkbutton = GTK_WIDGET (gtk_builder_get_object (builder, "use_custom_font_checkbutton"));
priv->editor_font_fontbutton = GTK_WIDGET (gtk_builder_get_object (builder, "editor_font_fontbutton"));
priv->editor_font_hbox = GTK_WIDGET (gtk_builder_get_object (builder, "editor_font_hbox"));
priv->unmark_fuzzy_when_changed_checkbutton = GTK_WIDGET (gtk_builder_get_object (builder, "unmark_fuzzy_checkbutton"));
priv->spellcheck_checkbutton = GTK_WIDGET (gtk_builder_get_object (builder, "spellcheck_checkbutton"));
priv->profile_treeview = GTK_WIDGET (gtk_builder_get_object (builder, "profile_treeview"));
priv->add_button = GTK_WIDGET (gtk_builder_get_object (builder, "add-button"));
priv->edit_button = GTK_WIDGET (gtk_builder_get_object (builder, "edit-button"));
priv->delete_button = GTK_WIDGET (gtk_builder_get_object (builder, "delete-button"));
profiles_toolbar = GTK_WIDGET (gtk_builder_get_object (builder, "profiles-toolbar"));
profiles_scrolled_window = GTK_WIDGET (gtk_builder_get_object (builder, "profiles-scrolledwindow"));
g_object_unref (builder);
gtk_box_pack_start (content_area, priv->notebook, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (priv->notebook), 5);
context = gtk_widget_get_style_context (profiles_scrolled_window);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_BOTTOM);
context = gtk_widget_get_style_context (profiles_toolbar);
gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP);
setup_files_pages (dlg);
setup_editor_pages (dlg);
setup_profile_pages (dlg);
}
static gboolean
refresh_account (GoaProvider *provider,
GoaClient *client,
GoaObject *object,
GtkWindow *parent,
GError **error)
{
AddAccountData data;
GVariantBuilder builder;
GoaAccount *account;
GoaEwsClient *ews_client;
GoaExchange *exchange;
GtkWidget *dialog;
GtkWidget *vbox;
gboolean accept_ssl_errors;
gboolean ret;
const gchar *email_address;
const gchar *server;
const gchar *password;
const gchar *username;
gint response;
g_return_val_if_fail (GOA_IS_EXCHANGE_PROVIDER (provider), FALSE);
g_return_val_if_fail (GOA_IS_CLIENT (client), FALSE);
g_return_val_if_fail (GOA_IS_OBJECT (object), FALSE);
g_return_val_if_fail (parent == NULL || GTK_IS_WINDOW (parent), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
ews_client = NULL;
ret = FALSE;
dialog = gtk_dialog_new_with_buttons (NULL,
parent,
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 12);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (vbox), 12);
memset (&data, 0, sizeof (AddAccountData));
data.loop = g_main_loop_new (NULL, FALSE);
data.dialog = GTK_DIALOG (dialog);
data.error = NULL;
create_account_details_ui (provider, GTK_DIALOG (dialog), GTK_BOX (vbox), FALSE, &data);
account = goa_object_peek_account (object);
email_address = goa_account_get_presentation_identity (account);
gtk_entry_set_text (GTK_ENTRY (data.email_address), email_address);
gtk_editable_set_editable (GTK_EDITABLE (data.email_address), FALSE);
gtk_widget_show_all (dialog);
ews_client = goa_ews_client_new ();
ews_again:
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response != GTK_RESPONSE_OK)
{
g_set_error (error,
GOA_ERROR,
GOA_ERROR_DIALOG_DISMISSED,
_("Dialog was dismissed"));
goto out;
}
password = gtk_entry_get_text (GTK_ENTRY (data.password));
username = goa_account_get_identity (account);
exchange = goa_object_peek_exchange (object);
accept_ssl_errors = goa_util_lookup_keyfile_boolean (object, "AcceptSslErrors");
server = goa_exchange_get_host (exchange);
goa_ews_client_autodiscover (ews_client,
email_address,
password,
username,
server,
accept_ssl_errors,
NULL,
autodiscover_cb,
&data);
goa_spinner_button_start (GOA_SPINNER_BUTTON (data.spinner_button));
g_main_loop_run (data.loop);
if (data.error != NULL)
{
GtkWidget *button;
gchar *markup;
markup = g_strdup_printf ("<b>%s:</b> %s",
_("Error connecting to Microsoft Exchange server"),
data.error->message);
g_clear_error (&data.error);
gtk_label_set_markup (GTK_LABEL (data.cluebar_label), markup);
g_free (markup);
button = gtk_dialog_get_widget_for_response (data.dialog, GTK_RESPONSE_OK);
gtk_button_set_label (GTK_BUTTON (button), _("_Try Again"));
gtk_widget_set_no_show_all (data.cluebar, FALSE);
gtk_widget_show_all (data.cluebar);
goto ews_again;
}
/* TODO: run in worker thread */
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&builder, "{sv}", "password", g_variant_new_string (password));
if (!goa_utils_store_credentials_for_object_sync (provider,
object,
g_variant_builder_end (&builder),
NULL, /* GCancellable */
error))
goto out;
goa_account_call_ensure_credentials (account,
NULL, /* GCancellable */
NULL, NULL); /* callback, user_data */
ret = TRUE;
out:
gtk_widget_destroy (dialog);
if (data.loop != NULL)
g_main_loop_unref (data.loop);
if (ews_client != NULL)
g_object_unref (ews_client);
return ret;
}
GtkWidget*
create_Config (void)
{
GtkWidget *Config;
GtkWidget *vbox4;
GtkWidget *frame7;
GtkWidget *alignment4;
GtkWidget *hbox8;
GtkWidget *radionointerlace;
GSList *radionointerlace_group = NULL;
GtkWidget *radiointerlace0;
GtkWidget *radiointerlace1;
GtkWidget *label13;
GtkWidget *checkBilinear;
GtkWidget *frame4;
GtkWidget *alignment1;
GtkWidget *hbox6;
GtkWidget *radioAANone;
GSList *radioAANone_group = NULL;
GtkWidget *radioAA2X;
GtkWidget *radioAA4X;
GtkWidget *radioAA8X;
GtkWidget *radioAA16X;
GtkWidget *label9;
GtkWidget *checkWireframe;
GtkWidget *checkAVI;
GtkWidget *checkTGA;
GtkWidget *checkfullscreen;
GtkWidget *frame5;
GtkWidget *alignment2;
GtkWidget *hbox7;
GtkWidget *radioSize640;
GSList *radioSize640_group = NULL;
GtkWidget *radioSize800;
GtkWidget *radioSize1024;
GtkWidget *radioSize1280;
GtkWidget *label10;
GtkWidget *frame6;
GtkWidget *alignment3;
GtkWidget *scrolledwindow1;
GtkWidget *treeview1;
GtkWidget *label12;
GtkWidget *label11;
GtkWidget *hbuttonbox1;
GtkWidget *button1;
GtkWidget *button2;
Config = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (Config), 5);
gtk_window_set_title (GTK_WINDOW (Config), _("ZeroOGS Configuration"));
vbox4 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox4);
gtk_container_add (GTK_CONTAINER (Config), vbox4);
frame7 = gtk_frame_new (NULL);
gtk_widget_show (frame7);
gtk_box_pack_start (GTK_BOX (vbox4), frame7, FALSE, FALSE, 0);
alignment4 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment4);
gtk_container_add (GTK_CONTAINER (frame7), alignment4);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment4), 0, 0, 12, 0);
hbox8 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox8);
gtk_container_add (GTK_CONTAINER (alignment4), hbox8);
radionointerlace = gtk_radio_button_new_with_mnemonic (NULL, _("Interlace Off"));
gtk_widget_show (radionointerlace);
gtk_box_pack_start (GTK_BOX (hbox8), radionointerlace, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radionointerlace), radionointerlace_group);
radionointerlace_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radionointerlace));
radiointerlace0 = gtk_radio_button_new_with_mnemonic (NULL, _("Interlace 0"));
gtk_widget_show (radiointerlace0);
gtk_box_pack_start (GTK_BOX (hbox8), radiointerlace0, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiointerlace0), radionointerlace_group);
radionointerlace_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiointerlace0));
radiointerlace1 = gtk_radio_button_new_with_mnemonic (NULL, _("Interlace 1"));
gtk_widget_show (radiointerlace1);
gtk_box_pack_start (GTK_BOX (hbox8), radiointerlace1, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiointerlace1), radionointerlace_group);
radionointerlace_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiointerlace1));
label13 = gtk_label_new (_("<b>Interlacing (F5 to toggle)</b>"));
gtk_widget_show (label13);
gtk_frame_set_label_widget (GTK_FRAME (frame7), label13);
gtk_label_set_use_markup (GTK_LABEL (label13), TRUE);
checkBilinear = gtk_check_button_new_with_mnemonic (_("Bilinear Filtering (Shift+F5)\n Best quality is on, turn off for speed"));
gtk_widget_show (checkBilinear);
gtk_box_pack_start (GTK_BOX (vbox4), checkBilinear, FALSE, FALSE, 0);
frame4 = gtk_frame_new (NULL);
gtk_widget_show (frame4);
gtk_box_pack_start (GTK_BOX (vbox4), frame4, FALSE, FALSE, 0);
alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (frame4), alignment1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 0, 0, 12, 0);
hbox6 = gtk_hbox_new (TRUE, 0);
gtk_widget_show (hbox6);
gtk_container_add (GTK_CONTAINER (alignment1), hbox6);
radioAANone = gtk_radio_button_new_with_mnemonic (NULL, _("None"));
gtk_widget_show (radioAANone);
gtk_box_pack_start (GTK_BOX (hbox6), radioAANone, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioAANone), radioAANone_group);
radioAANone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioAANone));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radioAANone), TRUE);
radioAA2X = gtk_radio_button_new_with_mnemonic (NULL, _("2X"));
gtk_widget_show (radioAA2X);
gtk_box_pack_start (GTK_BOX (hbox6), radioAA2X, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioAA2X), radioAANone_group);
radioAANone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioAA2X));
radioAA4X = gtk_radio_button_new_with_mnemonic (NULL, _("4X"));
gtk_widget_show (radioAA4X);
gtk_box_pack_start (GTK_BOX (hbox6), radioAA4X, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioAA4X), radioAANone_group);
radioAANone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioAA4X));
radioAA8X = gtk_radio_button_new_with_mnemonic (NULL, _("8X"));
gtk_widget_show (radioAA8X);
gtk_box_pack_start (GTK_BOX (hbox6), radioAA8X, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioAA8X), radioAANone_group);
radioAANone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioAA8X));
radioAA16X = gtk_radio_button_new_with_mnemonic (NULL, _("16X"));
gtk_widget_show (radioAA16X);
gtk_box_pack_start (GTK_BOX (hbox6), radioAA16X, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioAA16X), radioAANone_group);
radioAANone_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioAA16X));
label9 = gtk_label_new (_("<b>Anti-aliasing for higher quality (F6)</b>"));
gtk_widget_show (label9);
gtk_frame_set_label_widget (GTK_FRAME (frame4), label9);
gtk_label_set_use_markup (GTK_LABEL (label9), TRUE);
checkWireframe = gtk_check_button_new_with_mnemonic (_("Wireframe rendering (Shift+F6)"));
gtk_widget_show (checkWireframe);
gtk_box_pack_start (GTK_BOX (vbox4), checkWireframe, FALSE, FALSE, 0);
checkAVI = gtk_check_button_new_with_mnemonic (_("Capture Avi (zerogs.avi)(F7)"));
gtk_widget_show (checkAVI);
gtk_box_pack_start (GTK_BOX (vbox4), checkAVI, FALSE, FALSE, 0);
checkTGA = gtk_check_button_new_with_mnemonic (_("Save Snapshots as TGAs (default is JPG)"));
gtk_widget_show (checkTGA);
gtk_box_pack_start (GTK_BOX (vbox4), checkTGA, FALSE, FALSE, 0);
checkfullscreen = gtk_check_button_new_with_mnemonic (_("Fullscreen (Alt+Enter)\n to get out press Alt+Enter again (or ESC)"));
gtk_widget_show (checkfullscreen);
gtk_box_pack_start (GTK_BOX (vbox4), checkfullscreen, FALSE, FALSE, 0);
frame5 = gtk_frame_new (NULL);
gtk_widget_show (frame5);
gtk_box_pack_start (GTK_BOX (vbox4), frame5, FALSE, FALSE, 0);
alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (frame5), alignment2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 0, 0, 12, 0);
hbox7 = gtk_hbox_new (TRUE, 0);
gtk_widget_show (hbox7);
gtk_container_add (GTK_CONTAINER (alignment2), hbox7);
radioSize640 = gtk_radio_button_new_with_mnemonic (NULL, _("640x480"));
gtk_widget_show (radioSize640);
gtk_box_pack_start (GTK_BOX (hbox7), radioSize640, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioSize640), radioSize640_group);
radioSize640_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioSize640));
radioSize800 = gtk_radio_button_new_with_mnemonic (NULL, _("800x600"));
gtk_widget_show (radioSize800);
gtk_box_pack_start (GTK_BOX (hbox7), radioSize800, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioSize800), radioSize640_group);
radioSize640_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioSize800));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radioSize800), TRUE);
radioSize1024 = gtk_radio_button_new_with_mnemonic (NULL, _("1024x768"));
gtk_widget_show (radioSize1024);
gtk_box_pack_start (GTK_BOX (hbox7), radioSize1024, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioSize1024), radioSize640_group);
radioSize640_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioSize1024));
radioSize1280 = gtk_radio_button_new_with_mnemonic (NULL, _("1280x960"));
gtk_widget_show (radioSize1280);
gtk_box_pack_start (GTK_BOX (hbox7), radioSize1280, FALSE, FALSE, 0);
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radioSize1280), radioSize640_group);
radioSize640_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radioSize1280));
label10 = gtk_label_new (_("<b>Default Window Size (no speed impact)</b>"));
gtk_widget_show (label10);
gtk_frame_set_label_widget (GTK_FRAME (frame5), label10);
gtk_label_set_use_markup (GTK_LABEL (label10), TRUE);
frame6 = gtk_frame_new (NULL);
gtk_widget_show (frame6);
gtk_box_pack_start (GTK_BOX (vbox4), frame6, TRUE, TRUE, 0);
alignment3 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment3);
gtk_container_add (GTK_CONTAINER (frame6), alignment3);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment3), 0, 0, 12, 0);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow1);
gtk_container_add (GTK_CONTAINER (alignment3), scrolledwindow1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_SHADOW_IN);
treeview1 = gtk_tree_view_new ();
gtk_widget_show (treeview1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), treeview1);
label12 = gtk_label_new (_("<b>Advanced Options</b>"));
gtk_widget_show (label12);
gtk_frame_set_label_widget (GTK_FRAME (frame6), label12);
gtk_label_set_use_markup (GTK_LABEL (label12), TRUE);
label11 = gtk_label_new (_("Show Frames Per Second (Shift+F7)\n (value is the average over 4-16 PS2 frames)"));
gtk_widget_show (label11);
gtk_box_pack_start (GTK_BOX (vbox4), label11, FALSE, FALSE, 0);
hbuttonbox1 = gtk_hbutton_box_new ();
gtk_widget_show (hbuttonbox1);
gtk_box_pack_start (GTK_BOX (vbox4), hbuttonbox1, FALSE, FALSE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_SPREAD);
gtk_box_set_spacing (GTK_BOX (hbuttonbox1), 30);
button1 = gtk_button_new_with_mnemonic (_("Ok"));
gtk_widget_show (button1);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), button1);
GTK_WIDGET_SET_FLAGS (button1, GTK_CAN_DEFAULT);
button2 = gtk_button_new_with_mnemonic (_("Cancel"));
gtk_widget_show (button2);
gtk_container_add (GTK_CONTAINER (hbuttonbox1), button2);
GTK_WIDGET_SET_FLAGS (button2, GTK_CAN_DEFAULT);
g_signal_connect ((gpointer) button1, "clicked",
G_CALLBACK (OnConf_Ok),
NULL);
g_signal_connect ((gpointer) button2, "clicked",
G_CALLBACK (OnConf_Cancel),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (Config, Config, "Config");
GLADE_HOOKUP_OBJECT (Config, vbox4, "vbox4");
GLADE_HOOKUP_OBJECT (Config, frame7, "frame7");
GLADE_HOOKUP_OBJECT (Config, alignment4, "alignment4");
GLADE_HOOKUP_OBJECT (Config, hbox8, "hbox8");
GLADE_HOOKUP_OBJECT (Config, radionointerlace, "radionointerlace");
GLADE_HOOKUP_OBJECT (Config, radiointerlace0, "radiointerlace0");
GLADE_HOOKUP_OBJECT (Config, radiointerlace1, "radiointerlace1");
GLADE_HOOKUP_OBJECT (Config, label13, "label13");
GLADE_HOOKUP_OBJECT (Config, checkBilinear, "checkBilinear");
GLADE_HOOKUP_OBJECT (Config, frame4, "frame4");
GLADE_HOOKUP_OBJECT (Config, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (Config, hbox6, "hbox6");
GLADE_HOOKUP_OBJECT (Config, radioAANone, "radioAANone");
GLADE_HOOKUP_OBJECT (Config, radioAA2X, "radioAA2X");
GLADE_HOOKUP_OBJECT (Config, radioAA4X, "radioAA4X");
GLADE_HOOKUP_OBJECT (Config, radioAA8X, "radioAA8X");
GLADE_HOOKUP_OBJECT (Config, radioAA16X, "radioAA16X");
GLADE_HOOKUP_OBJECT (Config, label9, "label9");
GLADE_HOOKUP_OBJECT (Config, checkWireframe, "checkWireframe");
GLADE_HOOKUP_OBJECT (Config, checkAVI, "checkAVI");
GLADE_HOOKUP_OBJECT (Config, checkTGA, "checkTGA");
GLADE_HOOKUP_OBJECT (Config, checkfullscreen, "checkfullscreen");
GLADE_HOOKUP_OBJECT (Config, frame5, "frame5");
GLADE_HOOKUP_OBJECT (Config, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (Config, hbox7, "hbox7");
GLADE_HOOKUP_OBJECT (Config, radioSize640, "radioSize640");
GLADE_HOOKUP_OBJECT (Config, radioSize800, "radioSize800");
GLADE_HOOKUP_OBJECT (Config, radioSize1024, "radioSize1024");
GLADE_HOOKUP_OBJECT (Config, radioSize1280, "radioSize1280");
GLADE_HOOKUP_OBJECT (Config, label10, "label10");
GLADE_HOOKUP_OBJECT (Config, frame6, "frame6");
GLADE_HOOKUP_OBJECT (Config, alignment3, "alignment3");
GLADE_HOOKUP_OBJECT (Config, scrolledwindow1, "scrolledwindow1");
GLADE_HOOKUP_OBJECT (Config, treeview1, "treeview1");
GLADE_HOOKUP_OBJECT (Config, label12, "label12");
GLADE_HOOKUP_OBJECT (Config, label11, "label11");
GLADE_HOOKUP_OBJECT (Config, hbuttonbox1, "hbuttonbox1");
GLADE_HOOKUP_OBJECT (Config, button1, "button1");
GLADE_HOOKUP_OBJECT (Config, button2, "button2");
return Config;
}
static void
caja_file_conflict_dialog_init (CajaFileConflictDialog *fcd)
{
#if GTK_CHECK_VERSION (3, 0, 0)
GtkWidget *hbox, *vbox, *vbox2;
#else
GtkWidget *hbox, *vbox, *vbox2, *alignment;
#endif
GtkWidget *widget, *dialog_area;
CajaFileConflictDialogDetails *details;
GtkDialog *dialog;
details = fcd->details = CAJA_FILE_CONFLICT_DIALOG_GET_PRIVATE (fcd);
dialog = GTK_DIALOG (fcd);
/* Setup the main hbox */
hbox = gtk_hbox_new (FALSE, 12);
dialog_area = gtk_dialog_get_content_area (dialog);
gtk_box_pack_start (GTK_BOX (dialog_area), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
/* Setup the dialog image */
widget = gtk_image_new_from_icon_name ("dialog-warning",
GTK_ICON_SIZE_DIALOG);
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 0);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_set_halign (widget, GTK_ALIGN_CENTER);
gtk_widget_set_valign (widget, GTK_ALIGN_START);
#else
gtk_misc_set_alignment (GTK_MISC (widget), 0.5, 0.0);
#endif
/* Setup the vbox containing the dialog body */
vbox = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
/* Setup the vbox for the dialog labels */
widget = gtk_vbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0);
details->titles_vbox = widget;
/* Setup the hboxes to pack file infos into */
#if GTK_CHECK_VERSION (3, 0, 0)
vbox2 = gtk_vbox_new (FALSE, 12);
gtk_widget_set_halign (vbox2, GTK_ALIGN_START);
gtk_widget_set_valign (vbox2, GTK_ALIGN_START);
gtk_widget_set_margin_start (vbox2, 12);
gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
#else
alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
g_object_set (alignment, "left-padding", 12, NULL);
vbox2 = gtk_vbox_new (FALSE, 12);
gtk_container_add (GTK_CONTAINER (alignment), vbox2);
gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0);
#endif
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
details->first_hbox = hbox;
hbox = gtk_hbox_new (FALSE, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox, FALSE, FALSE, 0);
details->second_hbox = hbox;
/* Setup the expander for the rename action */
details->expander = gtk_expander_new_with_mnemonic (_("Select a new name for the _destination"));
gtk_box_pack_start (GTK_BOX (vbox2), details->expander, FALSE, FALSE, 0);
g_signal_connect (details->expander, "activate",
G_CALLBACK (expander_activated_cb), dialog);
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (details->expander), hbox);
widget = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 6);
details->entry = widget;
g_signal_connect (widget, "changed",
G_CALLBACK (entry_text_changed_cb), dialog);
widget = gtk_button_new_with_label (_("Reset"));
gtk_button_set_image (GTK_BUTTON (widget),
gtk_image_new_from_stock (GTK_STOCK_UNDO,
GTK_ICON_SIZE_MENU));
gtk_box_pack_start (GTK_BOX (hbox), widget, FALSE, FALSE, 6);
g_signal_connect (widget, "clicked",
G_CALLBACK (reset_button_clicked_cb), dialog);
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_show_all (vbox2);
#else
gtk_widget_show_all (alignment);
#endif
/* Setup the diff button for text files */
details->diff_button = gtk_button_new_with_label (_("Differences..."));
gtk_button_set_image (GTK_BUTTON (details->diff_button),
gtk_image_new_from_stock (GTK_STOCK_FIND,
GTK_ICON_SIZE_MENU));
gtk_box_pack_start (GTK_BOX (vbox), details->diff_button, FALSE, FALSE, 6);
g_signal_connect (details->diff_button, "clicked",
G_CALLBACK (diff_button_clicked_cb), dialog);
gtk_widget_hide (details->diff_button);
/* Setup the checkbox to apply the action to all files */
widget = gtk_check_button_new_with_mnemonic (_("Apply this action to all files"));
gtk_box_pack_start (GTK_BOX (vbox),
widget, FALSE, FALSE, 0);
details->checkbox = widget;
g_signal_connect (widget, "toggled",
G_CALLBACK (checkbox_toggled_cb), dialog);
/* Add buttons */
gtk_dialog_add_buttons (dialog,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
_("_Skip"),
CONFLICT_RESPONSE_SKIP,
NULL);
details->rename_button =
gtk_dialog_add_button (dialog,
_("Re_name"),
CONFLICT_RESPONSE_RENAME);
gtk_widget_hide (details->rename_button);
details->replace_button =
gtk_dialog_add_button (dialog,
_("Replace"),
CONFLICT_RESPONSE_REPLACE);
gtk_widget_grab_focus (details->replace_button);
/* Setup HIG properties */
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (dialog)), 14);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_widget_show_all (dialog_area);
}
gint
setup_game (GtkAction * action, gpointer data)
{
GtkWidget *box, *box2, *label, *button, *frame;
GtkWidget *grid;
GtkWidget *combo;
gchar *ts;
int i;
if (setupdialog) {
gtk_window_present (GTK_WINDOW (setupdialog));
return FALSE;
}
setupdialog = gtk_dialog_new_with_buttons (_("Tali Preferences"),
GTK_WINDOW (window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE, NULL);
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))), 2);
gtk_window_set_resizable (GTK_WINDOW (setupdialog), FALSE);
g_signal_connect (G_OBJECT (setupdialog), "delete_event",
G_CALLBACK (setupdialog_destroy), NULL);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
g_signal_connect (G_OBJECT (setupdialog), "response",
G_CALLBACK (do_setup), NULL);
grid = gtk_grid_new ();
gtk_container_set_border_width (GTK_CONTAINER (grid), 5);
gtk_grid_set_row_spacing (GTK_GRID (grid), 18);
gtk_grid_set_column_spacing (GTK_GRID (grid), 18);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (setupdialog))),
grid, FALSE, FALSE, 0);
frame = games_frame_new (_("Human Players"));
gtk_grid_attach (GTK_GRID (grid), frame, 0, 0, 1, 1);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (frame), box);
/*--- Spinner (number of humans) ---*/
OriginalNumberOfHumans = NumberOfHumans;
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Number of players:"));
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
HumanAdj = gtk_adjustment_new ((gfloat) NumberOfHumans, 1.0,
6.0, 1.0, 6.0, 0.0);
HumanSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (HumanAdj), 10, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), HumanSpinner);
g_signal_connect (G_OBJECT (HumanAdj), "value_changed",
G_CALLBACK (MaxPlayersCheck), HumanAdj);
gtk_box_pack_start (GTK_BOX (box2), HumanSpinner, TRUE, TRUE, 0);
frame = games_frame_new (_("Computer Opponents"));
gtk_grid_attach (GTK_GRID (grid), frame, 0, 1, 1, 1);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (frame), box);
/*--- Button ---*/
button = gtk_check_button_new_with_mnemonic (_("_Delay between rolls"));
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), DoDelay);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (set_as_int), &tmpDoDelay);
/*--- Spinner (number of computers) ---*/
OriginalNumberOfComputers = NumberOfComputers;
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("N_umber of opponents:"));
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
ComputerAdj = gtk_adjustment_new ((gfloat) NumberOfComputers,
0.0, 5.0, 1.0, 5.0, 0.0);
ComputerSpinner = gtk_spin_button_new (GTK_ADJUSTMENT (ComputerAdj), 10, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), ComputerSpinner);
g_signal_connect (G_OBJECT (ComputerAdj), "value_changed",
G_CALLBACK (MaxPlayersCheck), ComputerAdj);
gtk_box_pack_start (GTK_BOX (box2), ComputerSpinner, TRUE, TRUE, 0);
box2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start(GTK_BOX(box), box2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Difficulty:"));
gtk_box_pack_start(GTK_BOX(box2), label, FALSE, FALSE, 0);
combo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Easy"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Medium"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("difficulty", "Hard"));
skill_level = 0;
while (NUM_TRIALS > skill_level_table[skill_level].trials &&
skill_level < (SKILL_LEVEL_TABLE_SIZE - 1)) skill_level++;
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), skill_level);
g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetSkillLevel),
combo);
gtk_box_pack_start(GTK_BOX(box2), combo, FALSE, FALSE, 0);
/*--- Combo (yahtzee or kismet style ----*/
frame = games_frame_new (_("Game Type"));
gtk_grid_attach (GTK_GRID (grid), frame, 0, 2, 1, 1);
combo = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("game type", "Regular"));
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), C_("game type", "Colors"));
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), game_type);
NewGameType = game_type;
g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (SetGameType),
combo);
gtk_container_add (GTK_CONTAINER (frame), combo);
/*--- PLAYER NAMES FRAME ----*/
frame = games_frame_new (_("Player Names"));
gtk_grid_attach (GTK_GRID (grid), frame, 1, 0, 1, 3);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (frame), box);
for (i = 0; i < MAX_NUMBER_OF_PLAYERS; i++) {
box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (box), box2, FALSE, FALSE, 0);
ts = g_strdup_printf ("_%1d:", i + 1);
label = gtk_label_new_with_mnemonic (ts);
g_free (ts);
gtk_box_pack_start (GTK_BOX (box2), label, FALSE, FALSE, 0);
PlayerNames[i] = gtk_entry_new ();
gtk_label_set_mnemonic_widget (GTK_LABEL (label), PlayerNames[i]);
ts = g_strdup_printf ("PlayerName%1d", i + 1);
gtk_widget_set_name (PlayerNames[i], ts);
g_free (ts);
gtk_entry_set_text (GTK_ENTRY (PlayerNames[i]), players[i].name);
gtk_box_pack_start (GTK_BOX (box2), PlayerNames[i], FALSE, FALSE, 0);
}
gtk_widget_show_all (setupdialog);
return FALSE;
}
/*! \brief Creates the hotkeys dialog
* \par Function Description
* This function creates the hotkey dialog and puts the list of hotkeys
* into it.
*/
void x_dialog_hotkeys (GschemToplevel *w_current)
{
GtkWidget *vbox, *scrolled_win;
GtkTreeModel *store;
GtkWidget *treeview;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
if (!w_current->hkwindow) {
w_current->hkwindow = gschem_dialog_new_with_buttons(_("Hotkeys"),
GTK_WINDOW(w_current->main_window),
0, /* not modal */
"hotkeys", w_current,
GTK_STOCK_CLOSE,
GTK_RESPONSE_REJECT,
NULL);
gtk_window_set_position (GTK_WINDOW (w_current->hkwindow), GTK_WIN_POS_NONE);
g_signal_connect (G_OBJECT (w_current->hkwindow), "response",
G_CALLBACK (x_dialog_hotkeys_response),
w_current);
gtk_dialog_set_default_response(GTK_DIALOG(w_current->hkwindow),
GTK_RESPONSE_ACCEPT);
gtk_container_set_border_width (GTK_CONTAINER (w_current->hkwindow),
DIALOG_BORDER_SPACING);
gtk_widget_set_size_request (w_current->hkwindow, 300, 300);
vbox = GTK_DIALOG(w_current->hkwindow)->vbox;
gtk_box_set_spacing(GTK_BOX(vbox), DIALOG_V_SPACING);
scrolled_win = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
/* the model */
store = GTK_TREE_MODEL (gschem_hotkey_store_new ());
/* the tree view */
treeview = gtk_tree_view_new_with_model (store);
gtk_container_add(GTK_CONTAINER(scrolled_win), treeview);
/* the columns */
/* The first column contains the action's icon (if one was set)
* and its label. */
renderer = gtk_cell_renderer_pixbuf_new ();
column = gtk_tree_view_column_new_with_attributes (_("Action"),
renderer,
"stock-id",
GSCHEM_HOTKEY_STORE_COLUMN_ICON,
NULL);
/* Fix things up to show stock icons *and* theme icons. */
g_signal_connect (renderer, "notify::stock-id",
G_CALLBACK (x_dialog_hotkeys_cell_stock_id_notify),
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", GSCHEM_HOTKEY_STORE_COLUMN_LABEL,
NULL);
/* The second column contains the action's keybinding */
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
column = gtk_tree_view_column_new_with_attributes (_("Keystroke(s)"),
renderer,
"text",
GSCHEM_HOTKEY_STORE_COLUMN_KEYS,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);
/* show all recursively */
gtk_widget_show_all(w_current->hkwindow);
}
else { /* dialog already created */
gtk_window_present(GTK_WINDOW(w_current->hkwindow));
}
}
static GtkWidget * equalizerwin_create_list_window (Index * preset_list,
const gchar *title,
GtkWidget **window,
GtkSelectionMode sel_mode,
GtkWidget **entry,
const gchar *action_name,
GCallback action_func,
GCallback select_row_func)
{
GtkWidget *vbox, *scrolled_window, *bbox, *view;
GtkWidget *button_cancel, *button_action;
GtkListStore *store;
GtkTreeIter iter;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeSortable *sortable;
*window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(*window), title);
gtk_window_set_type_hint(GTK_WINDOW(*window), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_default_size(GTK_WINDOW(*window), 350, 300);
gtk_window_set_position(GTK_WINDOW(*window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(*window), 10);
gtk_window_set_transient_for(GTK_WINDOW(*window),
GTK_WINDOW(equalizerwin));
g_signal_connect(*window, "destroy",
G_CALLBACK(gtk_widget_destroyed), window);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_add(GTK_CONTAINER(*window), vbox);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
/* fill the store with the names of all available presets */
store = gtk_list_store_new(1, G_TYPE_STRING);
for (int p = 0; p < index_count (preset_list); p ++)
{
EqualizerPreset * preset = index_get (preset_list, p);
gtk_list_store_append(store, &iter);
gtk_list_store_set (store, & iter, 0, preset->name, -1);
}
model = GTK_TREE_MODEL(store);
sortable = GTK_TREE_SORTABLE(store);
gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_ASCENDING);
view = gtk_tree_view_new();
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1,
_("Presets"), renderer,
"text", 0, NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
g_object_unref(model);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, sel_mode);
gtk_container_add(GTK_CONTAINER(scrolled_window), view);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
if (entry) {
*entry = gtk_entry_new();
g_signal_connect(*entry, "activate", action_func, NULL);
gtk_box_pack_start(GTK_BOX(vbox), *entry, FALSE, FALSE, 0);
}
bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 5);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
button_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped (button_cancel, "clicked", (GCallback)
gtk_widget_destroy, * window);
gtk_box_pack_start(GTK_BOX(bbox), button_cancel, TRUE, TRUE, 0);
button_action = gtk_button_new_from_stock(action_name);
g_signal_connect(button_action, "clicked", G_CALLBACK(action_func), view);
gtk_widget_set_can_default (button_action, TRUE);
if (select_row_func)
g_signal_connect(view, "row-activated", G_CALLBACK(select_row_func), NULL);
gtk_box_pack_start(GTK_BOX(bbox), button_action, TRUE, TRUE, 0);
gtk_widget_grab_default(button_action);
gtk_widget_show_all(*window);
return *window;
}
void
procdialog_create_preferences_dialog (ProcData *procdata)
{
static GtkWidget *dialog = NULL;
typedef SpinButtonUpdater SBU;
static SBU interval_updater("update-interval");
static SBU graph_interval_updater("graph-update-interval");
static SBU disks_interval_updater("disks-interval");
GtkWidget *notebook;
GtkWidget *proc_box;
GtkWidget *sys_box;
GtkWidget *main_vbox;
GtkWidget *vbox, *vbox2, *vbox3;
GtkWidget *hbox, *hbox2, *hbox3;
GtkWidget *label;
GtkAdjustment *adjustment;
GtkWidget *spin_button;
GtkWidget *check_button;
GtkWidget *tab_label;
GtkWidget *smooth_button;
GtkSizeGroup *size;
gfloat update;
gchar *tmp;
if (prefs_dialog)
return;
size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
dialog = gtk_dialog_new_with_buttons (_("System Monitor Preferences"),
GTK_WINDOW (procdata->app),
GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-help", GTK_RESPONSE_HELP,
"gtk-close", GTK_RESPONSE_CLOSE,
NULL);
/* FIXME: we should not declare the window size, but let it's */
/* driven by window childs. The problem is that the fields list */
/* have to show at least 4 items to respect HIG. I don't know */
/* any function to set list height by contents/items inside it. */
gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 500);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
prefs_dialog = dialog;
main_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_set_spacing (GTK_BOX (main_vbox), 2);
notebook = gtk_notebook_new ();
gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
gtk_box_pack_start (GTK_BOX (main_vbox), notebook, TRUE, TRUE, 0);
proc_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
gtk_container_set_border_width (GTK_CONTAINER (proc_box), 12);
tab_label = gtk_label_new (_("Processes"));
gtk_widget_show (tab_label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), proc_box, tab_label);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (proc_box), vbox, FALSE, FALSE, 0);
tmp = g_strdup_printf ("<b>%s</b>", _("Behavior"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
update = (gfloat) procdata->config.update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0,
MIN_UPDATE_INTERVAL / 1000,
MAX_UPDATE_INTERVAL / 1000,
0.25,
1.0,
0);
spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
G_CALLBACK (SBU::callback), &interval_updater);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
smooth_button = gtk_check_button_new_with_mnemonic(_("Enable _smooth refresh"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(smooth_button),
g_settings_get_boolean(procdata->settings,
SmoothRefresh::KEY.c_str()));
g_signal_connect(G_OBJECT(smooth_button), "toggled",
G_CALLBACK(smooth_refresh_toggled), procdata);
gtk_box_pack_start(GTK_BOX(hbox2), smooth_button, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
check_button = gtk_check_button_new_with_mnemonic (_("Alert before ending or _killing processes"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
procdata->config.show_kill_warning);
g_signal_connect (G_OBJECT (check_button), "toggled",
G_CALLBACK (show_kill_dialog_toggled), procdata);
gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start(GTK_BOX(vbox2), hbox2, FALSE, FALSE, 0);
GtkWidget *solaris_button = gtk_check_button_new_with_mnemonic(_("Divide CPU usage by CPU count"));
gtk_widget_set_tooltip_text(solaris_button, _("Solaris mode"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(solaris_button),
g_settings_get_boolean(procdata->settings,
procman::settings::solaris_mode.c_str()));
g_signal_connect(G_OBJECT(solaris_button), "toggled",
G_CALLBACK(solaris_mode_toggled), procdata);
gtk_box_pack_start(GTK_BOX(hbox2), solaris_button, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (proc_box), vbox, TRUE, TRUE, 0);
tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox2 = create_field_page (procdata->tree, "proctree", _("Process i_nformation shown in list:"));
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
sys_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (sys_box), 12);
tab_label = gtk_label_new (_("Resources"));
gtk_widget_show (tab_label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (sys_box), vbox, FALSE, FALSE, 0);
tmp = g_strdup_printf ("<b>%s</b>", _("Graphs"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, TRUE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Update interval in 1/10 sec:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
gtk_size_group_add_widget (size, label);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
update = (gfloat) procdata->config.graph_update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new(update / 1000.0, 0.25,
100.0, 0.25, 1.0, 0);
spin_button = gtk_spin_button_new (adjustment, 1.0, 2);
g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
G_CALLBACK(SBU::callback),
&graph_interval_updater);
gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
GtkWidget *bits_button;
bits_button = gtk_check_button_new_with_mnemonic(_("Show network speed in bits"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(bits_button),
g_settings_get_boolean(procdata->settings,
procman::settings::network_in_bits.c_str()));
g_signal_connect(G_OBJECT(bits_button), "toggled",
G_CALLBACK(network_in_bits_toggled), procdata);
gtk_box_pack_start(GTK_BOX(vbox2), bits_button, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
/*
* Devices
*/
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
tab_label = gtk_label_new (_("File Systems"));
gtk_widget_show (tab_label);
gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, tab_label);
tmp = g_strdup_printf ("<b>%s</b>", _("File Systems"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (hbox), vbox2, TRUE, TRUE, 0);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic (_("_Update interval in seconds:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
hbox3 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
update = (gfloat) procdata->config.disks_update_interval;
adjustment = (GtkAdjustment *) gtk_adjustment_new (update / 1000.0, 1.0,
100.0, 1.0, 1.0, 0);
spin_button = gtk_spin_button_new (adjustment, 1.0, 0);
gtk_box_pack_start (GTK_BOX (hbox3), spin_button, FALSE, FALSE, 0);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), spin_button);
g_signal_connect (G_OBJECT (spin_button), "focus_out_event",
G_CALLBACK(SBU::callback),
&disks_interval_updater);
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
check_button = gtk_check_button_new_with_mnemonic (_("Show _all file systems"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (check_button),
procdata->config.show_all_fs);
g_signal_connect (G_OBJECT (check_button), "toggled",
G_CALLBACK (show_all_fs_toggled), procdata);
gtk_box_pack_start (GTK_BOX (hbox2), check_button, FALSE, FALSE, 0);
vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), vbox2, FALSE, FALSE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (vbox2), label, FALSE, FALSE, 0);
tmp = g_strdup_printf ("<b>%s</b>", _("Information Fields"));
label = gtk_label_new (NULL);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
label = gtk_label_new (" ");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
vbox3 = create_field_page (procdata->disk_list, "disktreenew", _("File system i_nformation shown in list:"));
gtk_box_pack_start (GTK_BOX (hbox), vbox3, TRUE, TRUE, 0);
gtk_widget_show_all (dialog);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (prefs_dialog_button_pressed), procdata);
switch (procdata->config.current_tab) {
case PROCMAN_TAB_SYSINFO:
case PROCMAN_TAB_PROCESSES:
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
break;
case PROCMAN_TAB_RESOURCES:
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 1);
break;
case PROCMAN_TAB_DISKS:
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 2);
break;
}
}
GtkWidget*
create_windowPreferences (void)
{
GtkWidget *windowPreferences;
GtkWidget *vboxPrefs;
GtkWidget *hboxUserName;
GtkWidget *labelUserName;
GtkWidget *entryUserName;
GtkWidget *hbuttonboxBtns;
GtkWidget *buttonCancel;
GtkWidget *buttonApply;
GtkWidget *hbox1;
GtkWidget *vbox2;
GtkWidget *frameHabits;
GtkWidget *hbox3;
GtkWidget *vbox3;
GtkWidget *treeviewHabits;
GtkWidget *vbuttonboxHabits;
GtkWidget *buttonAddHabit;
GtkWidget *buttonRemoveHabit;
GtkWidget *buttonEditHabit;
GtkWidget *label11;
windowPreferences = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name (windowPreferences, "windowPreferences");
gtk_window_set_title (GTK_WINDOW (windowPreferences), "Preferences");
gtk_window_set_resizable (GTK_WINDOW (windowPreferences), FALSE);
vboxPrefs = gtk_vbox_new (FALSE, 5);
gtk_widget_set_name (vboxPrefs, "vboxPrefs");
gtk_widget_show (vboxPrefs);
gtk_container_add (GTK_CONTAINER (windowPreferences), vboxPrefs);
gtk_container_set_border_width (GTK_CONTAINER (vboxPrefs), 3);
hboxUserName = gtk_hbox_new (FALSE, 5);
gtk_widget_set_name (hboxUserName, "hboxUserName");
gtk_widget_show (hboxUserName);
gtk_box_pack_start (GTK_BOX (vboxPrefs), hboxUserName, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (hboxUserName), 3);
labelUserName = gtk_label_new ("User name");
gtk_widget_set_name (labelUserName, "labelUserName");
gtk_widget_show (labelUserName);
gtk_box_pack_start (GTK_BOX (hboxUserName), labelUserName, FALSE, FALSE, 0);
entryUserName = gtk_entry_new ();
gtk_widget_set_name (entryUserName, "entryUserName");
gtk_widget_show (entryUserName);
gtk_box_pack_start (GTK_BOX (hboxUserName), entryUserName, FALSE, FALSE, 0);
gtk_entry_set_max_length (GTK_ENTRY (entryUserName), 20);
gtk_entry_set_width_chars (GTK_ENTRY (entryUserName), 21);
hbuttonboxBtns = gtk_hbutton_box_new ();
gtk_widget_set_name (hbuttonboxBtns, "hbuttonboxBtns");
gtk_widget_show (hbuttonboxBtns);
gtk_box_pack_end (GTK_BOX (vboxPrefs), hbuttonboxBtns, FALSE, FALSE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonboxBtns), GTK_BUTTONBOX_END);
gtk_box_set_spacing (GTK_BOX (hbuttonboxBtns), 5);
buttonCancel = gtk_button_new_from_stock ("gtk-cancel");
gtk_widget_set_name (buttonCancel, "buttonCancel");
gtk_widget_show (buttonCancel);
gtk_container_add (GTK_CONTAINER (hbuttonboxBtns), buttonCancel);
GTK_WIDGET_SET_FLAGS (buttonCancel, GTK_CAN_DEFAULT);
buttonApply = gtk_button_new_from_stock ("gtk-apply");
gtk_widget_set_name (buttonApply, "buttonApply");
gtk_widget_show (buttonApply);
gtk_container_add (GTK_CONTAINER (hbuttonboxBtns), buttonApply);
GTK_WIDGET_SET_FLAGS (buttonApply, GTK_CAN_DEFAULT);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_set_name (hbox1, "hbox1");
gtk_widget_show (hbox1);
gtk_box_pack_start (GTK_BOX (vboxPrefs), hbox1, TRUE, TRUE, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox2, "vbox2");
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (hbox1), vbox2, TRUE, TRUE, 0);
frameHabits = gtk_frame_new (NULL);
gtk_widget_set_name (frameHabits, "frameHabits");
gtk_widget_show (frameHabits);
gtk_box_pack_start (GTK_BOX (vbox2), frameHabits, TRUE, TRUE, 0);
hbox3 = gtk_hbox_new (FALSE, 5);
gtk_widget_set_name (hbox3, "hbox3");
gtk_widget_show (hbox3);
gtk_container_add (GTK_CONTAINER (frameHabits), hbox3);
gtk_container_set_border_width (GTK_CONTAINER (hbox3), 5);
vbox3 = gtk_vbox_new (FALSE, 0);
gtk_widget_set_name (vbox3, "vbox3");
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox3), vbox3, TRUE, TRUE, 0);
treeviewHabits = gtk_tree_view_new ();
gtk_widget_set_name (treeviewHabits, "treeviewHabits");
gtk_widget_show (treeviewHabits);
gtk_box_pack_start (GTK_BOX (vbox3), treeviewHabits, TRUE, TRUE, 0);
vbuttonboxHabits = gtk_vbutton_box_new ();
gtk_widget_set_name (vbuttonboxHabits, "vbuttonboxHabits");
gtk_widget_show (vbuttonboxHabits);
gtk_box_pack_start (GTK_BOX (hbox3), vbuttonboxHabits, FALSE, TRUE, 0);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonboxHabits), GTK_BUTTONBOX_START);
buttonAddHabit = gtk_button_new_from_stock ("gtk-add");
gtk_widget_set_name (buttonAddHabit, "buttonAddHabit");
gtk_widget_show (buttonAddHabit);
gtk_container_add (GTK_CONTAINER (vbuttonboxHabits), buttonAddHabit);
GTK_WIDGET_SET_FLAGS (buttonAddHabit, GTK_CAN_DEFAULT);
buttonRemoveHabit = gtk_button_new_from_stock ("gtk-remove");
gtk_widget_set_name (buttonRemoveHabit, "buttonRemoveHabit");
gtk_widget_show (buttonRemoveHabit);
gtk_container_add (GTK_CONTAINER (vbuttonboxHabits), buttonRemoveHabit);
gtk_widget_set_sensitive (buttonRemoveHabit, FALSE);
GTK_WIDGET_SET_FLAGS (buttonRemoveHabit, GTK_CAN_DEFAULT);
buttonEditHabit = gtk_button_new_from_stock ("gtk-properties");
gtk_widget_set_name (buttonEditHabit, "buttonEditHabit");
gtk_widget_show (buttonEditHabit);
gtk_container_add (GTK_CONTAINER (vbuttonboxHabits), buttonEditHabit);
gtk_widget_set_sensitive (buttonEditHabit, FALSE);
GTK_WIDGET_SET_FLAGS (buttonEditHabit, GTK_CAN_DEFAULT);
label11 = gtk_label_new ("Habits");
gtk_widget_set_name (label11, "label11");
gtk_widget_show (label11);
gtk_frame_set_label_widget (GTK_FRAME (frameHabits), label11);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (windowPreferences, windowPreferences, "windowPreferences");
GLADE_HOOKUP_OBJECT (windowPreferences, vboxPrefs, "vboxPrefs");
GLADE_HOOKUP_OBJECT (windowPreferences, hboxUserName, "hboxUserName");
GLADE_HOOKUP_OBJECT (windowPreferences, labelUserName, "labelUserName");
GLADE_HOOKUP_OBJECT (windowPreferences, entryUserName, "entryUserName");
GLADE_HOOKUP_OBJECT (windowPreferences, hbuttonboxBtns, "hbuttonboxBtns");
GLADE_HOOKUP_OBJECT (windowPreferences, buttonCancel, "buttonCancel");
GLADE_HOOKUP_OBJECT (windowPreferences, buttonApply, "buttonApply");
GLADE_HOOKUP_OBJECT (windowPreferences, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (windowPreferences, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (windowPreferences, frameHabits, "frameHabits");
GLADE_HOOKUP_OBJECT (windowPreferences, hbox3, "hbox3");
GLADE_HOOKUP_OBJECT (windowPreferences, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT (windowPreferences, treeviewHabits, "treeviewHabits");
GLADE_HOOKUP_OBJECT (windowPreferences, vbuttonboxHabits, "vbuttonboxHabits");
GLADE_HOOKUP_OBJECT (windowPreferences, buttonAddHabit, "buttonAddHabit");
GLADE_HOOKUP_OBJECT (windowPreferences, buttonRemoveHabit, "buttonRemoveHabit");
GLADE_HOOKUP_OBJECT (windowPreferences, buttonEditHabit, "buttonEditHabit");
GLADE_HOOKUP_OBJECT (windowPreferences, label11, "label11");
return windowPreferences;
}
