static SyncDialog *sync_dialog_new(GtkWidget *parent)
{
SyncDialog *sd;
GtkWidget *dialog;
GtkWidget *dialog1_vbox;
GtkWidget *scrolledwindow2;
GtkWidget *treeview2;
GtkWidget *dialog1_action_area;
GtkWidget *button8;
GtkWidget *button7;
GtkWidget *button6;
GtkWidget *label;
GtkWidget *hbox;
GtkTreeViewColumn *column;
GtkTreeModel *model;
GtkListStore *store;
GtkCellRenderer *cr_text, *cr_toggle;
sd = g_new0(SyncDialog, 1);
sd->sna = sync_dialog_netarea_new();
dialog = gtk_dialog_new();
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));
gtk_window_set_title(GTK_WINDOW(dialog), "Network Updater");
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_window_set_icon(GTK_WINDOW(dialog),
icon_cache_get_pixbuf("syncmanager.png"));
gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260);
gtk_window_set_position(GTK_WINDOW(dialog),
GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_type_hint(GTK_WINDOW(dialog),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
dialog1_vbox = GTK_DIALOG(dialog)->vbox;
gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5);
gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4);
gtk_widget_show(dialog1_vbox);
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new(LABEL_SYNC_DEFAULT);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox),
icon_cache_get_image("syncmanager.png"),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0);
gtk_widget_show_all(hbox);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), sd->sna->vbox, TRUE, TRUE,
0);
scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow2);
gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE,
0);
gtk_widget_set_size_request(scrolledwindow2, -1, 200);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW
(scrolledwindow2), GTK_SHADOW_IN);
store =
gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING,
G_TYPE_POINTER);
model = GTK_TREE_MODEL(store);
treeview2 = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE);
gtk_widget_show(treeview2);
gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column);
cr_toggle = gtk_cell_renderer_toggle_new();
gtk_tree_view_column_pack_start(column, cr_toggle, FALSE);
g_signal_connect(cr_toggle, "toggled", G_CALLBACK(sel_toggle), model);
gtk_tree_view_column_add_attribute(column, cr_toggle, "active", 0);
cr_text = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, cr_text, TRUE);
gtk_tree_view_column_add_attribute(column, cr_text, "markup", 1);
populate_store(store);
dialog1_action_area = GTK_DIALOG(dialog)->action_area;
gtk_widget_show(dialog1_action_area);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area),
GTK_BUTTONBOX_END);
button8 = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
gtk_widget_show(button8);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8,
GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT);
button7 = gtk_button_new_with_mnemonic("_Synchronize");
gtk_widget_show(button7);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7,
GTK_RESPONSE_ACCEPT);
GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT);
button6 = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect(G_OBJECT(button6), "clicked",
(GCallback) close_clicked, NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button6,
GTK_RESPONSE_ACCEPT);
GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT);
sd->dialog = dialog;
sd->button_sync = button7;
sd->button_cancel = button8;
sd->button_close = button6;
sd->scroll_box = scrolledwindow2;
sd->label = label;
return sd;
}
static void
setup_options (void)
{
MatePanelAppletsManager *manager;
GList *applet_list, *l;
int i;
int j;
char *prefs_path = NULL;
char *unique_key = NULL;
gboolean unique_key_found = FALSE;
gchar **dconf_paths;
GtkListStore *model;
GtkTreeIter iter;
GtkCellRenderer *renderer;
model = gtk_list_store_new (NUMBER_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_combo_box_set_model (GTK_COMBO_BOX (applet_combo),
GTK_TREE_MODEL (model));
manager = g_object_new (PANEL_TYPE_APPLETS_MANAGER_DBUS, NULL);
applet_list = MATE_PANEL_APPLETS_MANAGER_GET_CLASS (manager)->get_applets (manager);
for (l = applet_list, i = 1; l; l = g_list_next (l), i++) {
MatePanelAppletInfo *info = (MatePanelAppletInfo *)l->data;
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COLUMN_TEXT, g_strdup (mate_panel_applet_info_get_name (info)),
COLUMN_ITEM, g_strdup (mate_panel_applet_info_get_iid (info)),
-1);
}
g_list_free (applet_list);
g_object_unref (manager);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (applet_combo),
renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (applet_combo),
renderer, "text", COLUMN_TEXT, NULL);
gtk_combo_box_set_active (GTK_COMBO_BOX (applet_combo), 0);
setup_combo (size_combo, size_items, "Size",
G_N_ELEMENTS (size_items));
setup_combo (orient_combo, orient_items, "Orientation",
G_N_ELEMENTS (orient_items));
for (i = 0; !unique_key_found; i++)
{
unique_key = g_strdup_printf ("mate-panel-test-applet-%d", i);
unique_key_found = TRUE;
dconf_paths = mate_dconf_list_subdirs ("/tmp/", TRUE);
for (j = 0; dconf_paths[j] != NULL; j++)
{
if (g_strcmp0(unique_key, dconf_paths[j]) == 0) {
unique_key_found = FALSE;
break;
}
}
if (dconf_paths)
g_strfreev (dconf_paths);
}
prefs_path = g_strdup_printf ("/tmp/%s/", unique_key);
if (unique_key)
g_free (unique_key);
gtk_entry_set_text (GTK_ENTRY (prefs_path_entry), prefs_path);
g_free (prefs_path);
}
/*******************************************************
* Create the Assistant
*******************************************************/
static GtkWidget *
csv_import_assistant_create (CsvImportInfo *info)
{
GtkBuilder *builder;
GtkWidget *window;
GtkWidget *box, *h_box;
GtkWidget *button;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gchar *mnemonic_desc = NULL;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "assistant-csv-account-import.glade", "num_hrows_adj");
gnc_builder_add_from_file (builder, "assistant-csv-account-import.glade", "CSV Account Import Assistant");
window = GTK_WIDGET(gtk_builder_get_object (builder, "CSV Account Import Assistant"));
info->window = window;
/* Set the assistant colors */
gnc_assistant_set_colors (GTK_ASSISTANT (info->window));
/* Load default settings */
load_settings (info);
/* Enable buttons on all page. */
gtk_assistant_set_page_complete (GTK_ASSISTANT(window),
GTK_WIDGET(gtk_builder_get_object(builder, "start_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT(window),
GTK_WIDGET(gtk_builder_get_object(builder, "file_page")),
FALSE);
gtk_assistant_set_page_complete (GTK_ASSISTANT(window),
GTK_WIDGET(gtk_builder_get_object(builder, "import_tree_page")),
TRUE);
gtk_assistant_set_page_complete (GTK_ASSISTANT(window),
GTK_WIDGET(gtk_builder_get_object(builder, "end_page")),
FALSE);
gtk_assistant_set_page_complete (GTK_ASSISTANT(window),
GTK_WIDGET(gtk_builder_get_object(builder, "summary_page")),
TRUE);
/* Start Page */
/* File chooser Page */
info->file_chooser = gtk_file_chooser_widget_new (GTK_FILE_CHOOSER_ACTION_OPEN);
g_signal_connect (G_OBJECT(info->file_chooser), "file-activated",
G_CALLBACK(csv_import_file_chooser_confirm_cb), info);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
gtk_widget_set_size_request (button, 100, -1);
gtk_widget_show (button);
h_box = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX(h_box), button, FALSE, FALSE, 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER(info->file_chooser), h_box);
g_signal_connect (G_OBJECT(button), "clicked",
G_CALLBACK(csv_import_file_chooser_confirm_cb), info);
box = GTK_WIDGET(gtk_builder_get_object(builder, "file_page"));
gtk_box_pack_start (GTK_BOX(box), info->file_chooser, TRUE, TRUE, 6);
gtk_widget_show (info->file_chooser);
/* Account Tree Page */
info->header_row_spin = GTK_WIDGET(gtk_builder_get_object (builder, "num_hrows"));
info->tree_view = GTK_WIDGET(gtk_builder_get_object (builder, "treeview"));
/* Comma Separated file default */
info->regexp = g_string_new ("");
create_regex (info->regexp, ",");
/* create model and bind to view */
info->store = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW(info->tree_view), GTK_TREE_MODEL(info->store));
#define CREATE_COLUMN(description,column_id) \
renderer = gtk_cell_renderer_text_new (); \
mnemonic_desc = mnemonic_escape (_(description)); \
column = gtk_tree_view_column_new_with_attributes (mnemonic_desc, renderer, "text", column_id, NULL); \
gtk_tree_view_column_add_attribute (column, renderer, "background", ROW_COLOR); \
gtk_tree_view_column_set_resizable (column, TRUE); \
gtk_tree_view_append_column (GTK_TREE_VIEW(info->tree_view), column); \
g_free (mnemonic_desc);
CREATE_COLUMN ("type", TYPE);
CREATE_COLUMN ("full_name", FULL_NAME);
CREATE_COLUMN ("name", NAME);
CREATE_COLUMN ("code", CODE);
CREATE_COLUMN ("description", DESCRIPTION);
CREATE_COLUMN ("color", COLOR);
CREATE_COLUMN ("notes", NOTES);
CREATE_COLUMN ("commoditym", COMMODITYM);
CREATE_COLUMN ("commodityn", COMMODITYN);
CREATE_COLUMN ("hidden", HIDDEN);
CREATE_COLUMN ("tax", TAX);
CREATE_COLUMN ("place_holder", PLACE_HOLDER);
/* Finish Page */
info->finish_label = GTK_WIDGET(gtk_builder_get_object (builder, "end_page"));
/* Summary Page */
info->summary_label = GTK_WIDGET(gtk_builder_get_object (builder, "summary_label"));
info->summary_error_view = GTK_WIDGET(gtk_builder_get_object (builder, "summary_error_view"));
g_signal_connect (G_OBJECT(window), "destroy",
G_CALLBACK(csv_import_assistant_destroy_cb), info);
gnc_restore_window_size (GNC_PREFS_GROUP, GTK_WINDOW(info->window));
gtk_builder_connect_signals (builder, info);
g_object_unref (G_OBJECT(builder));
return window;
}
void clist_init(void)
{
GtkTreeView *view = GTK_TREE_VIEW(clist_wnd);
GtkTreeModel *model = GTK_TREE_MODEL(list);
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gint i;
list = gtk_list_store_new(CLIST_NCOLS, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_POINTER
);
model = GTK_TREE_MODEL(list);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(view, -1, "",
renderer, "pixbuf",
COLUMN_ICON, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"),
renderer, "text",
COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"),
renderer, "text",
COLUMN_TYPE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"),
renderer, "text",
COLUMN_SIZE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Date"),
renderer, "text",
COLUMN_DATE, NULL);
for (i = 0; i < CLIST_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(tree_selection_changed), NULL);
}
/*------------------------------main-----------------------------------*/
int main(int argc, char const *argv[])
{
debug("main");
/*command line args*/
if(argc > 1) {
if(!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
printf("%s\n", HELPMSG);
return 0;
}
if(!strcmp(argv[1], "-v") || !strcmp(argv[1], "--version")) {
printf("%s\n", VERSION);
return 0;
}
printf("Unknown args [%s], continue to GUI...\n", argv[1]);
}
/*gtk start*/
gtk_init(NULL, NULL);
debug("gtk init");
/*init char*/
mark = malloc(2);
word = malloc(MAX_LENGTH);
/* init curl */
curl_global_init(CURL_GLOBAL_ALL);
debug("curl init");
/*window*/
window = (GtkWidget *)gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_window_set_icon_name(GTK_WINDOW(window),"accessories-dictionary");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_gravity(GTK_WINDOW(window), GDK_GRAVITY_CENTER);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(window, "key_press_event", G_CALLBACK(checkEsc), NULL);
debug("window");
/* entry */
make_entry();
/*button*/
make_button1();
/*assemble*/
vbox1 = gtk_vbox_new(FALSE, 2); /*h**o, pad*/
hbox1 = gtk_hbox_new(FALSE, 2);
hboxmain = gtk_hbox_new(FALSE, 5);
gtk_widget_set_no_show_all(hboxmain, TRUE);
gtk_container_add((GtkContainer *)window, vbox1);
gtk_container_add((GtkContainer *)vbox1, hbox1);
gtk_container_add((GtkContainer *)vbox1, hboxmain);
gtk_container_add((GtkContainer *)hbox1, entry);
gtk_container_add((GtkContainer *)hbox1, button1);
gtk_box_set_child_packing(GTK_BOX(hbox1), GTK_WIDGET(entry),
1,/*expand*/
1,/*fill*/
2,/*pad*/
GTK_PACK_START/*pack type*/
);
gtk_box_set_child_packing(GTK_BOX(vbox1), hbox1,
0, 0, 1, GTK_PACK_START);
gtk_box_set_child_packing(GTK_BOX(hbox1), button1,
0, 0, 1, GTK_PACK_START);
debug("assemble initial view");
gtk_widget_show_all(window);
debug("start the show");
#ifdef MinGW
/*volatino*/
volatino = (GtkWidget *) gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated(GTK_WINDOW(volatino), FALSE);
gtk_widget_set_size_request(volatino, 450, 24);
gtk_window_set_icon_name(GTK_WINDOW(volatino),"accessories-dictionary");
gtk_window_set_position(GTK_WINDOW(volatino), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_gravity(GTK_WINDOW(volatino), GDK_GRAVITY_CENTER);
gtk_widget_show(volatino);
gtk_widget_destroy(volatino);
#endif
/*auto-completion*/
store = gtk_list_store_new(1, G_TYPE_STRING);
model = GTK_TREE_MODEL(store);
/*completion model*/
completion = gtk_entry_completion_new();
gtk_entry_completion_set_model(completion, model);
gtk_entry_completion_set_text_column(completion, 0);
/*completion style*/
gtk_entry_completion_set_inline_completion(completion, TRUE);
gtk_entry_completion_set_inline_selection(completion, TRUE);
/*commands*/
append_list(store, ":about");
append_list(store, ":help");
/*connect completion*/
gtk_entry_set_completion(GTK_ENTRY(entry), completion);
debug("completion");
debug("gtk main entering");
gtk_main();
/*gtk end*/
debug("Sure.");
/*clean up*/
if(curl_handle)
curl_easy_cleanup(curl_handle);
curl_global_cleanup();
free(s);
free(rslt);
free(mark);
free(word);
if(searchStr)
free(searchStr);
return 0;
}
static GtkWidget *
servlist_open_networks (void)
{
GtkWidget *servlist;
GtkWidget *vbox1;
GtkWidget *label2;
GtkWidget *table1;
GtkWidget *label3;
GtkWidget *label4;
GtkWidget *label5;
GtkWidget *label6;
GtkWidget *label7;
GtkWidget *entry1;
GtkWidget *entry2;
GtkWidget *entry3;
GtkWidget *entry4;
GtkWidget *entry5;
GtkWidget *vbox2;
GtkWidget *label1;
GtkWidget *table4;
GtkWidget *scrolledwindow3;
GtkWidget *treeview_networks;
GtkWidget *checkbutton_skip;
GtkWidget *vbuttonbox2;
GtkWidget *button_add;
GtkWidget *button_remove;
GtkWidget *button_edit;
GtkWidget *button_sort;
GtkWidget *button_connect;
GtkTreeModel *model;
GtkListStore *store;
GtkCellRenderer *renderer;
servlist =
mg_create_generic_tab(_("Network List"), _("conspire: Networks"),
FALSE, TRUE, servlist_close_cb, NULL, 640, 480, &vbox1, NULL);
label2 = bold_label (_("User Information"));
gtk_box_pack_start (GTK_BOX (vbox1), label2, FALSE, FALSE, 0);
table1 = gtk_table_new (5, 2, FALSE);
gtk_widget_show (table1);
gtk_box_pack_start (GTK_BOX (vbox1), table1, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table1), 8);
gtk_table_set_row_spacings (GTK_TABLE (table1), 2);
gtk_table_set_col_spacings (GTK_TABLE (table1), 4);
label3 = gtk_label_new_with_mnemonic (_("_Nick name:"));
gtk_widget_show (label3);
gtk_table_attach (GTK_TABLE (table1), label3, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label3), 0, 0.5);
label4 = gtk_label_new (_("Second choice:"));
gtk_widget_show (label4);
gtk_table_attach (GTK_TABLE (table1), label4, 0, 1, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label4), 0, 0.5);
label5 = gtk_label_new (_("Third choice:"));
gtk_widget_show (label5);
gtk_table_attach (GTK_TABLE (table1), label5, 0, 1, 2, 3,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label5), 0, 0.5);
label6 = gtk_label_new_with_mnemonic (_("_User name:"));
gtk_widget_show (label6);
gtk_table_attach (GTK_TABLE (table1), label6, 0, 1, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label6), 0, 0.5);
label7 = gtk_label_new_with_mnemonic (_("Rea_l name:"));
gtk_widget_show (label7);
gtk_table_attach (GTK_TABLE (table1), label7, 0, 1, 4, 5,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label7), 0, 0.5);
entry_nick1 = entry1 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry1), prefs.nick1);
gtk_widget_show (entry1);
gtk_table_attach (GTK_TABLE (table1), entry1, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry_nick2 = entry2 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry2), prefs.nick2);
gtk_widget_show (entry2);
gtk_table_attach (GTK_TABLE (table1), entry2, 1, 2, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry_nick3 = entry3 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry3), prefs.nick3);
gtk_widget_show (entry3);
gtk_table_attach (GTK_TABLE (table1), entry3, 1, 2, 2, 3,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry_guser = entry4 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry4), prefs.username);
gtk_widget_show (entry4);
gtk_table_attach (GTK_TABLE (table1), entry4, 1, 2, 3, 4,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
entry_greal = entry5 = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (entry5), prefs.realname);
gtk_widget_show (entry5);
gtk_table_attach (GTK_TABLE (table1), entry5, 1, 2, 4, 5,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_box_pack_start (GTK_BOX (vbox1), vbox2, TRUE, TRUE, 0);
label1 = bold_label (_("Networks"));
gtk_box_pack_start (GTK_BOX (vbox2), label1, FALSE, FALSE, 0);
table4 = gtk_table_new (2, 2, FALSE);
gtk_widget_show (table4);
gtk_box_pack_start (GTK_BOX (vbox2), table4, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (table4), 8);
gtk_table_set_row_spacings (GTK_TABLE (table4), 2);
gtk_table_set_col_spacings (GTK_TABLE (table4), 3);
scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow3);
gtk_table_attach (GTK_TABLE (table4), scrolledwindow3, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow3),
GTK_SHADOW_IN);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
model = GTK_TREE_MODEL (store);
networks_tree = treeview_networks = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_widget_show (treeview_networks);
gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview_networks);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_networks),
FALSE);
renderer = gtk_cell_renderer_text_new ();
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (servlist_celledit_cb), model);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (treeview_networks), -1,
0, renderer,
"text", 0,
"editable", 1,
NULL);
checkbutton_skip =
gtk_check_button_new_with_mnemonic (_("Skip network list on startup"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (checkbutton_skip),
prefs.skip_serverlist);
g_signal_connect (G_OBJECT (checkbutton_skip), "toggled",
G_CALLBACK (no_servlist), 0);
gtk_widget_show (checkbutton_skip);
gtk_table_attach (GTK_TABLE (table4), checkbutton_skip, 0, 2, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
vbuttonbox2 = gtk_vbutton_box_new ();
gtk_box_set_spacing (GTK_BOX (vbuttonbox2), 3);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox2), GTK_BUTTONBOX_START);
gtk_widget_show (vbuttonbox2);
gtk_table_attach (GTK_TABLE (table4), vbuttonbox2, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
button_add = gtk_button_new_from_stock ("gtk-add");
g_signal_connect (G_OBJECT (button_add), "clicked",
G_CALLBACK (servlist_addnet_cb), networks_tree);
gtk_widget_show (button_add);
gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_add);
GTK_WIDGET_SET_FLAGS (button_add, GTK_CAN_DEFAULT);
button_remove = gtk_button_new_from_stock ("gtk-remove");
g_signal_connect (G_OBJECT (button_remove), "clicked",
G_CALLBACK (servlist_deletenet_cb), 0);
gtk_widget_show (button_remove);
gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_remove);
GTK_WIDGET_SET_FLAGS (button_remove, GTK_CAN_DEFAULT);
button_edit = gtk_button_new_with_mnemonic (_("_Edit..."));
g_signal_connect (G_OBJECT (button_edit), "clicked",
G_CALLBACK (servlist_edit_cb), 0);
gtk_widget_show (button_edit);
gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_edit);
GTK_WIDGET_SET_FLAGS (button_edit, GTK_CAN_DEFAULT);
button_sort = gtk_button_new_with_mnemonic (_("_Sort"));
add_tip (button_sort, _("Sorts the network list in alphabetical order. "
"Use SHIFT-UP and SHIFT-DOWN keys to move a row."));
g_signal_connect (G_OBJECT (button_sort), "clicked",
G_CALLBACK (servlist_sort), 0);
gtk_widget_show (button_sort);
gtk_container_add (GTK_CONTAINER (vbuttonbox2), button_sort);
GTK_WIDGET_SET_FLAGS (button_sort, GTK_CAN_DEFAULT);
button_connect = gtkutil_button (vbuttonbox2, GTK_STOCK_CONNECT, NULL,
servlist_connect_cb, NULL, _("C_onnect"));
GTK_WIDGET_SET_FLAGS (button_connect, GTK_CAN_DEFAULT);
gtk_label_set_mnemonic_widget (GTK_LABEL (label3), entry1);
gtk_label_set_mnemonic_widget (GTK_LABEL (label6), entry4);
gtk_label_set_mnemonic_widget (GTK_LABEL (label7), entry5);
gtk_widget_grab_focus (networks_tree);
return servlist;
}
/***************************
* *
* Encodings dialog window *
* *
**************************/
void
gxi_edit_encodings_clicked_cb (GtkButton *button, GncXmlImportData *data)
{
GtkBuilder *builder;
GtkWidget *dialog;
GtkListStore *list_store;
GtkTreeStore *tree_store;
GtkTreeIter iter, parent, *parent_ptr;
GList *encodings_bak, *enc_iter;
const gchar *encoding;
system_encoding_type *system_enc;
gpointer enc_ptr;
gint i, j;
builder = gtk_builder_new();
gnc_builder_add_from_file (builder, "assistant-xml-encoding.glade", "encodings_dialog");
dialog = GTK_WIDGET(gtk_builder_get_object (builder, "encodings_dialog"));
data->encodings_dialog = dialog;
// Set the style context for this assistant so it can be easily manipulated with css
gnc_widget_set_style_context (GTK_WIDGET(dialog), "GncAssistXmlEncoding");
gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, data);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (data->assistant));
data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view"));
data->custom_enc_entry = GTK_WIDGET(gtk_builder_get_object (builder, "custom_enc_entry"));
/* set up selected encodings list */
data->selected_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "selected_encs_view"));
list_store = gtk_list_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER);
for (enc_iter = data->encodings; enc_iter; enc_iter = enc_iter->next)
{
encoding = g_quark_to_string (GPOINTER_TO_UINT (enc_iter->data));
gtk_list_store_append (list_store, &iter);
gtk_list_store_set (list_store, &iter, ENC_COL_STRING, encoding,
ENC_COL_QUARK, enc_iter->data, -1);
}
gtk_tree_view_insert_column_with_attributes (
data->selected_encs_view, -1, NULL,
gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL);
gtk_tree_view_set_model (data->selected_encs_view,
GTK_TREE_MODEL (list_store));
g_object_unref (list_store);
/* set up system encodings list */
data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view"));
tree_store = gtk_tree_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER);
for (i = 0, system_enc = system_encodings;
i < n_system_encodings;
i++, system_enc++)
{
if (i == 0)
{
/* first system encoding */
parent_ptr = NULL;
}
else
{
parent_ptr = &iter;
for (j = 0; j < system_enc->parent; j++)
if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (tree_store),
&parent, &iter))
{
/* go up one level */
iter = parent;
}
else
{
/* no parent to toplevel element */
parent_ptr = NULL;
}
}
if (system_enc->encoding)
enc_ptr = GUINT_TO_POINTER (g_quark_from_string (system_enc->encoding));
else
enc_ptr = NULL;
gtk_tree_store_append (tree_store, &iter, parent_ptr);
gtk_tree_store_set (tree_store, &iter, ENC_COL_STRING,
gettext (system_enc->text), ENC_COL_QUARK, enc_ptr, -1);
}
gtk_tree_view_insert_column_with_attributes (
data->available_encs_view, -1, NULL,
gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL);
gtk_tree_view_set_model (data->available_encs_view,
GTK_TREE_MODEL (tree_store));
g_object_unref (tree_store);
/* run the dialog */
encodings_bak = g_list_copy (data->encodings);
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
g_list_free (encodings_bak);
if (!g_list_find (data->encodings,
GUINT_TO_POINTER (data->default_encoding)))
{
/* choose top level encoding then */
data->default_encoding = GPOINTER_TO_UINT (data->encodings->data);
}
/* update whole page */
gxi_check_file (data);
gxi_update_default_enc_combo (data);
gxi_update_string_box (data);
gxi_update_conversion_forward (data);
}
else
{
g_list_free (data->encodings);
data->encodings = encodings_bak;
}
g_object_unref(G_OBJECT(builder));
gtk_widget_destroy (dialog);
data->encodings_dialog = NULL;
}
void *
userlist_create_model (void)
{
return gtk_list_store_new (5, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_POINTER, GDK_TYPE_COLOR);
}
void
gui_create_tasks(GUI *appGUI) {
GtkWidget *vbox1;
GtkWidget *vbox2;
GtkWidget *table;
GtkWidget *label;
GtkWidget *top_scrolledwindow;
GtkWidget *hseparator;
GtkWidget *close_button;
GtkCellRenderer *renderer;
GtkWidget *top_viewport;
GtkWidget *bottom_viewport;
GtkTextBuffer *text_buffer;
GError *error = NULL;
GtkActionGroup *action_group = NULL;
gchar tmpbuf[BUFFER_SIZE];
const gchar *ui_info =
" <toolbar name=\"toolbar\">\n"
" <toolitem name=\"add\" action=\"add\" />\n"
" <toolitem name=\"delete\" action=\"delete\" />\n"
" <separator name=\"sep1\" />\n"
" <toolitem name=\"edit\" action=\"edit\" />\n"
" </toolbar>\n";
GtkActionEntry entries[] = {
{ "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL },
{ "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL },
{ "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL },
};
guint n_entries = G_N_ELEMENTS (entries);
appGUI->tsk->filter_index = 0;
vbox1 = gtk_vbox_new (FALSE, 1);
gtk_widget_show (vbox1);
gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8);
sprintf(tmpbuf, "<b>%s</b>", _("Tasks"));
gui_add_to_notebook (vbox1, tmpbuf, appGUI);
appGUI->tsk->vbox = GTK_BOX(vbox1);
/*-------------------------------------------------------------------------------------*/
action_group = gtk_action_group_new ("_actions");
gtk_action_group_add_actions (action_group, entries, n_entries, NULL);
gtk_action_group_set_sensitive(action_group, TRUE);
appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new ();
gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0);
g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI);
if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) {
g_message ("building toolbar failed: %s", error->message);
g_error_free (error);
}
gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget);
gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS);
gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips);
/*-------------------------------------------------------------------------------------*/
/* assign callbacks */
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked",
G_CALLBACK(tasks_add_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked",
G_CALLBACK(tasks_edit_item_cb), appGUI);
g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked",
G_CALLBACK(tasks_remove_item_cb), appGUI);
/*-------------------------------------------------------------------------------------*/
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE);
gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
table = gtk_table_new (1, 4, FALSE);
gtk_widget_show (table);
gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 8);
sprintf(tmpbuf, "<b>%s:</b>", _("Category filter"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
appGUI->tsk->cf_combobox = gtk_combo_box_new_text ();
gtk_widget_show (appGUI->tsk->cf_combobox);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE);
GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
g_signal_connect(appGUI->tsk->cf_combobox, "changed",
G_CALLBACK(category_filter_cb), appGUI);
g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus",
G_CALLBACK(category_combo_box_focus_cb), NULL);
appGUI->tsk->n_items_label = gtk_label_new ("");
gtk_widget_show (appGUI->tsk->n_items_label);
gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1);
gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE);
hseparator = gtk_hseparator_new ();
gtk_widget_show (hseparator);
gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6);
/*-------------------------------------------------------------------------------------*/
appGUI->tsk->tasks_paned = gtk_vpaned_new();
gtk_widget_show (appGUI->tsk->tasks_paned);
gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999);
gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0);
top_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (top_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE);
gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE);
top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (top_scrolledwindow);
gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL);
gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter),
(GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb,
appGUI, NULL);
appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter));
appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint);
gtk_widget_show (appGUI->tsk->tasks_list);
GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT);
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED]));
gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL,
(& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL]));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event",
G_CALLBACK(list_dbclick_cb), appGUI);
appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list));
g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed",
G_CALLBACK(tasks_item_selected), appGUI);
/* create columns */
renderer = gtk_cell_renderer_toggle_new();
appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"),
renderer,
"active", COLUMN_DONE,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]);
g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"),
renderer,
"text", COLUMN_DUE_DATE,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_DUE_DATE_JULIAN,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_START_DATE_JULIAN,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"),
renderer,
"text", COLUMN_PRIORITY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"),
renderer,
"text", COLUMN_CATEGORY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_renderer_set_fixed_size(renderer, 0, -1);
appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"),
renderer,
"text", COLUMN_SUMMARY,
"strikethrough", COLUMN_DONE,
"foreground", COLUMN_COLOR,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"),
renderer,
"text", COLUMN_DESCRIPTION,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]);
renderer = gtk_cell_renderer_text_new();
appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL,
renderer,
"text", COLUMN_COLOR,
NULL);
gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE);
gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]);
/* configure list options */
gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE);
/* configure sorting */
gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0,
(GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order);
gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order);
/*----------------------------------------------------------------------------*/
bottom_viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (bottom_viewport);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE);
gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE);
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0);
gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2);
appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0);
gtk_widget_show(appGUI->tsk->panel_hbox);
sprintf(tmpbuf, "%s:", _("Task details"));
label = gtk_label_new (tmpbuf);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0);
if (config.default_stock_icons) {
close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE);
} else {
close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE);
}
GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS);
gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL);
gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0);
g_signal_connect (G_OBJECT (close_button), "clicked",
G_CALLBACK (panel_close_desc_cb), appGUI);
appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (appGUI->tsk->panel_scrolledwindow);
gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
appGUI->tsk->tasks_desc_textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE);
gtk_widget_show (appGUI->tsk->tasks_desc_textview);
gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview);
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview));
gtk_text_buffer_create_tag (text_buffer, "italic",
"style", PANGO_STYLE_ITALIC, NULL);
appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font",
"font", (gchar *) config.task_info_font, NULL);
}
static void
gb_book_links_construct (GbBookLinks *self)
{
GbBookLinksPrivate *priv;
GtkWidget *swindow;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
priv = self->priv;
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow),
GTK_SHADOW_IN);
/* Create tree view */
priv->tree_view = gtk_tree_view_new ();
gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->tree_view), TRUE);
g_signal_connect_swapped (priv->tree_view, "row-activated",
G_CALLBACK (schedule_emit_link_activated), self);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (priv->tree_view), 20);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->tree_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (swindow), priv->tree_view);
gtk_box_pack_start (GTK_BOX (self), swindow, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (self));
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (column), TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (priv->tree_view), column);
renderer = (GtkCellRenderer *)
g_object_new (GTK_TYPE_CELL_RENDERER_TEXT,
"ellipsize", PANGO_ELLIPSIZE_END,
"weight", PANGO_WEIGHT_BOLD,
"xpad", 10,
NULL);
gtk_tree_view_column_pack_start (GTK_TREE_VIEW_COLUMN (column), renderer, TRUE);
gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
"markup", BOOK_LINKS_COLUMN_MARKUP,
NULL);
renderer = gd_styled_text_renderer_new ();
gd_styled_text_renderer_add_class (GD_STYLED_TEXT_RENDERER (renderer), "dim-label");
g_object_set (renderer,
"max-width-chars", 12,
"scale", PANGO_SCALE_SMALL,
"xalign", 1.0,
"xpad", 10,
NULL);
gtk_tree_view_column_pack_end (GTK_TREE_VIEW_COLUMN (column), renderer, FALSE);
/*
gtk_tree_view_column_set_attributes (GTK_TREE_VIEW_COLUMN (column), renderer,
"text", BOOK_LINKS_COLUMN_LABEL,
NULL);
*/
priv->model = (GtkTreeModel *)gtk_list_store_new (BOOK_LINKS_COLUMN_N,
G_TYPE_STRING,
G_TYPE_STRING);
}
static void
pkg_channel_page_init (PkgChannelPage *page)
{
PkgChannelPagePrivate *priv;
gchar *path;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
ENTRY;
page->priv = G_TYPE_INSTANCE_GET_PRIVATE(page,
PKG_TYPE_CHANNEL_PAGE,
PkgChannelPagePrivate);
priv = page->priv;
#define EXTRACT_WIDGET(_n, _w) \
G_STMT_START { \
priv->_w = (gpointer)gtk_builder_get_object(priv->builder, _n); \
} G_STMT_END
path = pkg_path_for_data("ui", "pkg-channel-page.ui", NULL);
priv->builder = gtk_builder_new();
gtk_builder_add_from_file(priv->builder, path, NULL);
g_free(path);
EXTRACT_WIDGET("page-label", page_label);
EXTRACT_WIDGET("channel-page", container);
EXTRACT_WIDGET("target", target);
EXTRACT_WIDGET("args", args);
EXTRACT_WIDGET("working-dir", working_dir);
EXTRACT_WIDGET("env", env);
EXTRACT_WIDGET("pid", pid);
EXTRACT_WIDGET("kill-pid", kill_pid);
EXTRACT_WIDGET("exit-status", exit_status);
EXTRACT_WIDGET("muted", muted);
EXTRACT_WIDGET("sources", sources);
gtk_widget_unparent(priv->container);
gtk_container_add(GTK_CONTAINER(page), priv->container);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("ID"));
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->sources), column);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, cell, TRUE);
gtk_tree_view_column_add_attribute(column, cell, "text", COLUMN_IDSTR);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Plugin"));
gtk_tree_view_append_column(GTK_TREE_VIEW(priv->sources), column);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, cell, TRUE);
gtk_tree_view_column_add_attribute(column, cell, "text", COLUMN_PLUGIN);
priv->model = gtk_list_store_new(3,
G_TYPE_INT,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->sources),
GTK_TREE_MODEL(priv->model));
EXIT;
}
int handle_lobby(GladeXML* g_lobby_xml, GladeXML* g_table_info_xml, GladeXML* g_lobby_tabs_xml, GladeXML* g_cashier_button_xml, GladeXML* g_clock_xml, GtkLayout* screen, int init)
{
static int s_selected_table = 0;
s_screen = screen;
if(init) {
textdomain ("poker2d");
int i;
s_lobby_xml = g_lobby_xml;
s_lobby_window = gui_get_widget(g_lobby_xml, "lobby_window");
g_assert(s_lobby_window);
set_nil_draw_focus(s_lobby_window);
if(screen) gtk_layout_put(screen, s_lobby_window, 0, 0);
s_notebook = GTK_NOTEBOOK(gui_get_widget(g_lobby_xml, "notebook"));
g_assert(s_notebook);
for(i = 0; i < VARIANTS_COUNT; i++) {
char tmp[32];
s_variants_store[i] = gtk_list_store_new(12, G_TYPE_INT,
GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING
);
snprintf(tmp, 32, "%s_treeview", s_variants_names[i]);
GtkTreeView* treeview = GTK_TREE_VIEW(gui_get_widget(g_lobby_xml, tmp));
GtkTreeSelection* selection = gtk_tree_view_get_selection(treeview);
g_signal_connect(selection, "changed", (GCallback)on_lobby_list_treeview_selection_changed, &s_selected_table);
s_variants_selection[i] = selection;
g_signal_connect(treeview, "row-activated", (GCallback)on_row_activated, &s_selected_table);
gtk_tree_view_set_rules_hint(treeview, TRUE);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(s_variants_store[i]));
GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new();
#define TABLE_COLUMN_ID 0
#define TABLE_COLUMN_MY 1
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
GtkCellRenderer* pixbuf_renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_title(column, gettext("My") );
gtk_tree_view_column_pack_start(column, pixbuf_renderer, TRUE);
gtk_tree_view_column_add_attribute(column, pixbuf_renderer, "pixbuf", TABLE_COLUMN_MY);
}
{
GError* error = 0;
gchar* filename;
filename = glade_xml_relative_file(g_lobby_xml, "table_bullet_my.png");
if(g_file_test(filename, G_FILE_TEST_EXISTS)) {
pixbuf_table_my = gdk_pixbuf_new_from_file(filename, &error);
if(pixbuf_table_my == NULL) {
GtkIconTheme* theme = gtk_icon_theme_get_default();
error = 0;
pixbuf_table_my = gtk_icon_theme_load_icon(theme,
"stock_book_open",
16,
0,
&error);
if (!pixbuf_table_my) {
g_warning ("Couldn't load icon: %s", error->message);
}
}
}
g_free(filename);
}
#define SET_COLUMN(TITLE, INDEX) \
{ \
GtkTreeViewColumn* column = gtk_tree_view_column_new(); \
gtk_tree_view_append_column(treeview, column); \
gtk_tree_view_column_set_title(column, TITLE); \
gtk_tree_view_column_pack_start(column, text_renderer, TRUE); \
gtk_tree_view_column_add_attribute(column, text_renderer, "text", INDEX); \
}
#define TABLE_COLUMN_NAME 2
SET_COLUMN( gettext("Name"), TABLE_COLUMN_NAME);
#define TABLE_COLUMN_STRUCTURE 3
SET_COLUMN( gettext("Structure"), TABLE_COLUMN_STRUCTURE);
#define TABLE_COLUMN_SEATS 4
SET_COLUMN( gettext("Seats"), TABLE_COLUMN_SEATS);
#define TABLE_COLUMN_AVG_POT 5
SET_COLUMN( gettext("Avg.pot"), TABLE_COLUMN_AVG_POT);
#define TABLE_COLUMN_HANDS_PER_HOUR 6
SET_COLUMN( gettext("Hands/h"), TABLE_COLUMN_HANDS_PER_HOUR);
#define TABLE_COLUMN_PERCENT_FLOP 7
SET_COLUMN( gettext("Flop%"), TABLE_COLUMN_PERCENT_FLOP);
#define TABLE_COLUMN_PLAYING 8
SET_COLUMN( gettext("Playing"), TABLE_COLUMN_PLAYING);
#define TABLE_COLUMN_OBSERVING 9
#define TABLE_COLUMN_WAITING 10
#define TABLE_COLUMN_TIMEOUT 11
#undef SET_COLUMN
}
s_players_label = GTK_LABEL(gui_get_widget(g_lobby_xml, "players_label"));
s_tables_label = GTK_LABEL(gui_get_widget(g_lobby_xml, "tables_label"));
GUI_BRANCH(g_lobby_xml, on_all_radio_clicked);
GUI_BRANCH(g_lobby_xml, on_money_one_radio_clicked);
GUI_BRANCH(g_lobby_xml, on_money_two_radio_clicked);
s_table_info_window = gui_get_widget(g_table_info_xml, "table_info_window");
g_assert(s_table_info_window);
if(screen) gtk_layout_put(screen, s_table_info_window, 0, 0);
{
s_players_store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
GtkTreeView* treeview = GTK_TREE_VIEW(gui_get_widget(g_table_info_xml, "players_treeview"));
gtk_tree_view_set_rules_hint(treeview, TRUE);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(s_players_store));
GtkCellRenderer* text_renderer = gtk_cell_renderer_text_new();
#define PLAYERS_COLUMN_NAME 0
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_title(column, gettext("Players") );
gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
gtk_tree_view_column_add_attribute(column, text_renderer, "text", 0);
}
#define PLAYERS_COLUMN_CHIPS 1
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_title(column, gettext("Chips") );
gtk_tree_view_column_pack_start(column, text_renderer, TRUE);
gtk_tree_view_column_add_attribute(column, text_renderer, "text", 1);
}
#define PLAYERS_COLUMN_FLAG 2
}
s_go_to_label = GTK_LABEL(glade_xml_get_widget(g_table_info_xml, "label_go_to"));
s_go_to_button = GTK_BUTTON(glade_xml_get_widget(g_table_info_xml, "button_go_to"));
g_signal_connect(GTK_OBJECT(s_go_to_button), "clicked", (GtkSignalFunc)on_go_to_clicked, &s_selected_table);
s_lobby_tabs_window = gui_get_widget(g_lobby_tabs_xml, "lobby_tabs_window");
g_assert(s_lobby_tabs_window);
gtk_widget_set_size_request(s_lobby_tabs_window, gui_width(screen), -1);
if(screen) gtk_layout_put(screen, s_lobby_tabs_window, 0, 0);
GUI_BRANCH(g_lobby_tabs_xml, on_table_toggled);
GUI_BRANCH(g_lobby_tabs_xml, on_tourney_toggled);
s_cashier_button_window = gui_get_widget(g_cashier_button_xml, "cashier_button_window");
g_assert(s_cashier_button_window);
if(screen) gtk_layout_put(screen, s_cashier_button_window, 0, 0);
s_cashier_button = GTK_BUTTON(gui_get_widget(g_cashier_button_xml, "cashier_button"));
g_assert(s_cashier_button);
GUI_BRANCH(g_cashier_button_xml, on_cashier_button_pressed);
s_clock_window = gui_get_widget(g_clock_xml, "clock_window");
g_assert(s_clock_window);
if(screen) gtk_layout_put(screen, s_clock_window, 0, 0);
s_clock_label = gui_get_widget(g_clock_xml, "clock_label");
close_lobby();
}
char* tag = get_string();
if(!strcmp(tag, "show")) {
g_lobby_tab_state = lobby;
{
char* label = get_string();
gtk_button_set_label(s_cashier_button, label);
g_free(label);
}
if (screen != NULL || s_lobby_shown == 0)
{
//
// calculate windows position
//
int screen_width = gui_width(screen);
int screen_height = gui_height(screen);
int top_left_x = (screen_width - 1000) / 2;
int top_left_y = (screen_height - 450) / 2;
{
static position_t position;
position.x = screen_width - 610;
position.y = top_left_y;
gui_place(s_lobby_window, &position, screen);
}
{
static position_t position;
position.x = top_left_x;
position.y = top_left_y;
gui_place(s_table_info_window, &position, screen);
}
{
static position_t position;
position.x = 0;
position.y = 33;
gui_place(s_lobby_tabs_window, &position, screen);
}
{
static position_t position;
position.x = top_left_x;
position.y = top_left_y + 435;
gui_place(s_cashier_button_window, &position, screen);
}
s_lobby_shown = 1;
}
{
gui_bottom_right(s_clock_window, screen);
}
s_selected_table = 0;
{
char* type = get_string();
if(!strcmp(type, "holdem")) {
gtk_notebook_set_current_page(s_notebook, VARIANT_HOLDEM);
} else if(!strcmp(type, "omaha")) {
gtk_notebook_set_current_page(s_notebook, VARIANT_OMAHA);
} else if(!strcmp(type, "omaha8")) {
gtk_notebook_set_current_page(s_notebook, VARIANT_OMAHA8);
} else if(!strcmp(type, "7stud")) {
gtk_notebook_set_current_page(s_notebook, VARIANT_7STUD);
}
GtkToggleButton* button = GTK_TOGGLE_BUTTON(gui_get_widget(g_lobby_tabs_xml, type));
g_assert(button);
gtk_toggle_button_set_active(button, TRUE);
g_free(type);
}
{
char* currency_serial = get_string();
char* button;
GtkWidget* radio;
if(!strcmp(currency_serial, "money_two")) {
button = "money_two_radio";
} else if(!strcmp(currency_serial, "money_one")) {
button = "money_one_radio";
} else {
button = "all_radio";
}
{
//moneyone
GtkWidget* sl = gui_get_widget(g_lobby_xml, "money_one_radio");
char* label = get_string();
gtk_button_set_label(GTK_BUTTON(sl), label);
g_free(label);
}
{
//moneytwo
GtkWidget* sl = gui_get_widget(g_lobby_xml, "money_two_radio");
char* label = get_string();
gtk_button_set_label(GTK_BUTTON(sl), label);
g_free(label);
}
s_disable_buttons = 1;
radio = gui_get_widget(s_lobby_xml, button);
g_assert(radio);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio), TRUE);
s_disable_buttons = 0;
g_free(currency_serial);
}
} else if(!strcmp(tag, "hide")) {
g_lobby_tab_state = none;
close_lobby();
} else if(!strcmp(tag, "info")) {
char* players_count = get_string();
char* tables_count = get_string();
gtk_label_set_text(s_players_label, players_count);
gtk_label_set_text(s_tables_label, tables_count);
g_free(players_count);
g_free(tables_count);
} else if(!strcmp(tag, "holdem") || !strcmp(tag, "omaha") ||
!strcmp(tag, "omaha8") || !strcmp(tag, "7stud")) {
int selected = get_int();
int rows = get_int();
int i;
int variant_index = VARIANT_HOLDEM;
if(!strcmp(tag, "holdem")) {
variant_index = VARIANT_HOLDEM;
} else if(!strcmp(tag, "omaha")) {
variant_index = VARIANT_OMAHA;
} else if(!strcmp(tag, "omaha8")) {
variant_index = VARIANT_OMAHA8;
} else if(!strcmp(tag, "7stud")) {
variant_index = VARIANT_7STUD;
}
gtk_list_store_clear(s_variants_store[variant_index]);
for(i = 0; i < rows; i++) {
int id = get_int();
GtkTreeIter iter;
gtk_list_store_append(s_variants_store[variant_index], &iter);
gtk_list_store_set(s_variants_store[variant_index], &iter, TABLE_COLUMN_ID, id, -1);
if(selected == id)
gtk_tree_selection_select_iter(s_variants_selection[variant_index], &iter);
{
char* my = get_string();
GdkPixbuf* pixbuf = 0;
if(!strcmp(my, "yes")) {
pixbuf = pixbuf_table_my;
}
gtk_list_store_set(s_variants_store[variant_index], &iter, TABLE_COLUMN_MY, pixbuf, -1);
}
#define SET_COLUMN(INDEX) \
{ \
char* content = get_string(); \
gtk_list_store_set(s_variants_store[variant_index], &iter, INDEX, content, -1); \
g_free(content); \
}
SET_COLUMN(TABLE_COLUMN_NAME);
SET_COLUMN(TABLE_COLUMN_STRUCTURE);
SET_COLUMN(TABLE_COLUMN_SEATS);
SET_COLUMN(TABLE_COLUMN_AVG_POT);
SET_COLUMN(TABLE_COLUMN_HANDS_PER_HOUR);
SET_COLUMN(TABLE_COLUMN_PERCENT_FLOP);
SET_COLUMN(TABLE_COLUMN_PLAYING);
SET_COLUMN(TABLE_COLUMN_OBSERVING);
SET_COLUMN(TABLE_COLUMN_WAITING);
SET_COLUMN(TABLE_COLUMN_TIMEOUT);
#undef SET_COLUMN
}
s_selected_table = selected;
if(!selected) {
gtk_list_store_clear(s_players_store);
gtk_widget_set_sensitive(GTK_WIDGET(s_go_to_button), FALSE);
}
} else if(!strcmp(tag, "players")) {
int players_count = get_int();
int i;
gtk_label_set_text(s_go_to_label, gettext("GO TO TABLE") );
gtk_widget_set_sensitive(GTK_WIDGET(s_go_to_button), TRUE);
gtk_list_store_clear(s_players_store);
for(i = 0; i < players_count; i++) {
char* name = get_string();
char* chips = get_string();
int flag = get_int();
GtkTreeIter iter;
gtk_list_store_append(s_players_store, &iter);
gtk_list_store_set(s_players_store, &iter, PLAYERS_COLUMN_NAME, name, PLAYERS_COLUMN_CHIPS, chips, PLAYERS_COLUMN_FLAG, flag, -1);
g_free(name);
g_free(chips);
}
}
//
// set clock time
//
{
time_t _time;
char date_buffer[8];
time(&_time);
struct tm* _tm = gmtime(&_time);
snprintf(date_buffer, sizeof (date_buffer), "%02d:%02d",
_tm->tm_hour, _tm->tm_min);
gtk_label_set_text(GTK_LABEL(s_clock_label), date_buffer);
}
g_free(tag);
return TRUE;
}
static GtkWidget * equalizerwin_create_list_window (Index * preset_list,
const gchar *title,
GtkWidget **window,
GtkSelectionMode sel_mode,
GtkWidget **entry,
GtkWidget *button_action,
GCallback action_func,
GCallback select_row_func)
{
GtkWidget *vbox, *scrolled_window, *bbox, *view;
GtkWidget *button_cancel;
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_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);
audgui_destroy_on_escape (* 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_shadow_type ((GtkScrolledWindow *) scrolled_window, GTK_SHADOW_IN);
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 = audgui_button_new (_("Cancel"), "process-stop", NULL, NULL);
g_signal_connect_swapped (button_cancel, "clicked", (GCallback)
gtk_widget_destroy, * window);
gtk_box_pack_start(GTK_BOX(bbox), button_cancel, TRUE, TRUE, 0);
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;
}
static void
prepare_list (AppearanceData *data, GtkWidget *list, ThemeType type, GCallback callback)
{
GtkListStore *store;
GList *l, *themes = NULL;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *sort_model;
GdkPixbuf *thumbnail;
const gchar *key;
ThumbnailGenFunc generator;
ThemeThumbnailFunc thumb_cb;
ThemeConvData *conv_data;
GSettings *settings;
switch (type)
{
case THEME_TYPE_GTK:
themes = mate_theme_info_find_by_type (MATE_THEME_GTK_2);
thumbnail = data->gtk_theme_icon;
settings = data->interface_settings;
key = GTK_THEME_KEY;
generator = (ThumbnailGenFunc) generate_gtk_theme_thumbnail_async;
thumb_cb = (ThemeThumbnailFunc) gtk_theme_thumbnail_cb;
break;
case THEME_TYPE_WINDOW:
themes = mate_theme_info_find_by_type (MATE_THEME_MARCO);
thumbnail = data->window_theme_icon;
settings = data->marco_settings;
key = MARCO_THEME_KEY;
generator = (ThumbnailGenFunc) generate_marco_theme_thumbnail_async;
thumb_cb = (ThemeThumbnailFunc) marco_theme_thumbnail_cb;
break;
case THEME_TYPE_ICON:
themes = mate_theme_icon_info_find_all ();
thumbnail = data->icon_theme_icon;
settings = data->interface_settings;
key = ICON_THEME_KEY;
generator = (ThumbnailGenFunc) generate_icon_theme_thumbnail_async;
thumb_cb = (ThemeThumbnailFunc) icon_theme_thumbnail_cb;
break;
case THEME_TYPE_CURSOR:
themes = mate_theme_cursor_info_find_all ();
thumbnail = NULL;
settings = data->mouse_settings;
key = CURSOR_THEME_KEY;
generator = NULL;
thumb_cb = NULL;
break;
default:
/* we don't deal with any other type of themes here */
return;
}
store = gtk_list_store_new (NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING);
for (l = themes; l; l = g_list_next (l))
{
MateThemeCommonInfo *theme = (MateThemeCommonInfo *) l->data;
GtkTreeIter i;
if (type == THEME_TYPE_CURSOR) {
thumbnail = ((MateThemeCursorInfo *) theme)->thumbnail;
} else {
generator (theme, thumb_cb, data, NULL);
}
gtk_list_store_insert_with_values (store, &i, 0,
COL_LABEL, theme->readable_name,
COL_NAME, theme->name,
COL_THUMBNAIL, thumbnail,
-1);
if (type == THEME_TYPE_CURSOR && thumbnail) {
g_object_unref (thumbnail);
thumbnail = NULL;
}
}
g_list_free (themes);
sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
COL_LABEL, GTK_SORT_ASCENDING);
if (type == THEME_TYPE_CURSOR)
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort_model), COL_LABEL,
(GtkTreeIterCompareFunc) cursor_theme_sort_func,
NULL, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (list), GTK_TREE_MODEL (sort_model));
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "xpad", 3, "ypad", 3, NULL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "pixbuf", COL_THUMBNAIL);
gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "text", COL_LABEL);
gtk_tree_view_append_column (GTK_TREE_VIEW (list), column);
conv_data = g_new (ThemeConvData, 1);
conv_data->data = data;
conv_data->thumbnail = thumbnail;
/* set useful data for callbacks */
g_object_set_data (G_OBJECT (list), THEME_DATA, conv_data);
g_object_set_data (G_OBJECT (list), GSETTINGS_SETTINGS, settings);
g_object_set_data (G_OBJECT (list), GSETTINGS_KEY, g_strdup(key));
/* select in treeview the theme set in gsettings */
GtkTreeModel *treemodel;
treemodel = gtk_tree_view_get_model (GTK_TREE_VIEW (list));
gchar *theme = g_settings_get_string (settings, key);
gchar *path = find_string_in_model (treemodel, theme, COL_NAME);
if (path)
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (list));
GtkTreePath *treepath = gtk_tree_path_new_from_string (path);
gtk_tree_selection_select_path (selection, treepath);
gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (list), treepath, NULL, FALSE, 0, 0);
gtk_tree_path_free (treepath);
g_free (path);
}
if (theme)
g_free (theme);
/* connect to gsettings change event */
gchar *signal_name = g_strdup_printf("changed::%s", key);
g_signal_connect (settings, signal_name,
G_CALLBACK (treeview_gsettings_changed_callback), list);
g_free (signal_name);
/* connect to treeview change event */
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (list)),
"changed", G_CALLBACK (treeview_selection_changed_callback), list);
}
// Create and bind the tree model to the tree view for the audio track list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_audio_tree_model (signal_user_data_t *ud)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
GtkListStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkWidget *widget;
g_debug("bind_audio_tree_model ()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "audio_list"));
selection = gtk_tree_view_get_selection (treeview);
// 12 columns in model. 6 are visible, the other 6 are for storing
// values that I need
treestore = gtk_list_store_new(6, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Track"), cell, "text", 0, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 200);
gtk_tree_view_column_set_max_width (column, 200);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Codec"), cell, "text", 1, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 110);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Bitrate"), cell, "text", 2, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 50);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Sample Rate"), cell, "text", 3, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 100);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Mix"), cell, "text", 4, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 115);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("DRC"), cell, "text", 5, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(selection, "changed", audio_list_selection_changed_cb, ud);
// Need to disable remove and update buttons since there are initially
// no selections
widget = GHB_WIDGET (ud->builder, "audio_remove");
gtk_widget_set_sensitive(widget, FALSE);
g_debug("Done\n");
}
GtkWidget *
create_disk_view(ProcData *procdata)
{
GtkWidget *disk_box;
GtkWidget *scrolled;
GtkWidget *disk_tree;
GtkListStore *model;
GtkTreeViewColumn *col;
GtkCellRenderer *cell;
guint i;
const gchar * const titles[] = {
N_("Device"),
N_("Directory"),
N_("Type"),
N_("Total"),
N_("Free"),
N_("Available"),
N_("Used")
};
disk_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_container_set_border_width(GTK_CONTAINER(disk_box), 12);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(disk_box), scrolled, TRUE, TRUE, 0);
model = gtk_list_store_new(DISK_N_COLUMNS, /* n columns */
G_TYPE_STRING, /* DISK_DEVICE */
G_TYPE_STRING, /* DISK_DIR */
G_TYPE_STRING, /* DISK_TYPE */
G_TYPE_UINT64, /* DISK_TOTAL */
G_TYPE_UINT64, /* DISK_FREE */
G_TYPE_UINT64, /* DISK_AVAIL */
G_TYPE_UINT64, /* DISK_USED */
GDK_TYPE_PIXBUF, /* DISK_ICON */
G_TYPE_INT /* DISK_USED_PERCENTAGE */
);
disk_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
g_signal_connect(G_OBJECT(disk_tree), "row-activated", G_CALLBACK(open_dir), NULL);
procdata->disk_list = disk_tree;
gtk_container_add(GTK_CONTAINER(scrolled), disk_tree);
g_object_unref(G_OBJECT(model));
/* icon + device */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "pixbuf", DISK_ICON,
NULL);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell, "text", DISK_DEVICE,
NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_DEVICE]));
gtk_tree_view_column_set_sort_column_id(col, DISK_DEVICE);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_min_width (col, 30);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
/* sizes - used */
for (i = DISK_DIR; i <= DISK_AVAIL; i++) {
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_title(col, _(titles[i]));
gtk_tree_view_column_set_sort_column_id(col, i);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_min_width (col, 30);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
switch (i) {
case DISK_TOTAL:
case DISK_FREE:
case DISK_AVAIL:
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_cell_data_func,
GUINT_TO_POINTER(i),
NULL);
break;
default:
gtk_tree_view_column_set_attributes(col, cell,
"text", i,
NULL);
break;
}
}
/* used + percentage */
col = gtk_tree_view_column_new();
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "xalign", 1.0f, NULL);
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_cell_data_func(col, cell,
&procman::size_cell_data_func,
GUINT_TO_POINTER(DISK_USED),
NULL);
cell = gtk_cell_renderer_progress_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_attributes(col, cell, "value",
DISK_USED_PERCENTAGE, NULL);
gtk_tree_view_column_set_title(col, _(titles[DISK_USED]));
gtk_tree_view_column_set_sort_column_id(col, DISK_USED);
gtk_tree_view_column_set_reorderable(col, TRUE);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_min_width (col, 150);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
g_signal_connect(G_OBJECT(col), "notify::fixed-width", G_CALLBACK(cb_disks_column_resized), procdata->settings);
gtk_tree_view_append_column(GTK_TREE_VIEW(disk_tree), col);
/* numeric sort */
gtk_widget_show_all(disk_box);
procman_get_tree_state(procdata->settings, disk_tree,
"disktreenew");
g_signal_connect (G_OBJECT(disk_tree), "columns-changed",
G_CALLBACK(cb_disk_columns_changed), procdata);
return disk_box;
}
// Create and bind the tree model to the tree view for the subtitle track list
// Also, connect up the signal that lets us know the selection has changed
static void
bind_subtitle_tree_model (signal_user_data_t *ud)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *column;
GtkListStore *treestore;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GtkWidget *widget;
g_debug("bind_subtitle_tree_model ()\n");
treeview = GTK_TREE_VIEW(GHB_WIDGET (ud->builder, "subtitle_list"));
selection = gtk_tree_view_get_selection (treeview);
// 6 columns in model. 5 are visible, the other 1 is for storing
// values that I need
// Track, force, burn, default, type, srt offset, track short, source
// force visible, burn visible, offset visible
treestore = gtk_list_store_new(10,
G_TYPE_STRING,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_INT, G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_BOOLEAN, G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(treestore));
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Track"), cell, "text", 0, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
gtk_tree_view_column_set_min_width (column, 350);
gtk_tree_view_column_set_max_width (column, 350);
cell = gtk_cell_renderer_toggle_new();
column = gtk_tree_view_column_new_with_attributes(
_("Forced Only"), cell, "active", 1, "visible", 7, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_forced_toggled_cb, ud);
cell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell), TRUE);
column = gtk_tree_view_column_new_with_attributes(
_("Burned In"), cell, "active", 2, "visible", 8, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_burned_toggled_cb, ud);
cell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_radio(GTK_CELL_RENDERER_TOGGLE(cell), TRUE);
column = gtk_tree_view_column_new_with_attributes(
_("Default"), cell, "active", 3, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(cell, "toggled", subtitle_default_toggled_cb, ud);
cell = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_("Srt Offset"), cell, "text", 4, "visible", 9, NULL);
gtk_tree_view_append_column(treeview, GTK_TREE_VIEW_COLUMN(column));
g_signal_connect(selection, "changed", subtitle_list_selection_changed_cb, ud);
// Need to disable remove and update buttons since there are initially
// no selections
widget = GHB_WIDGET (ud->builder, "subtitle_remove");
gtk_widget_set_sensitive(widget, FALSE);
g_debug("Done\n");
}
void
initialize_pref_controls(void)
{
GtkWidget *widget;
GtkSpinButton *spin;
GdkColor color;
GtkTreeModel *model;
diag_pref = glade_xml_get_widget (appdata.xml, "diag_pref");
/* Updates controls from values of variables */
widget = glade_xml_get_widget (appdata.xml, "node_radius_slider");
gtk_adjustment_set_value (GTK_RANGE (widget)->adjustment,
log (pref.node_radius_multiplier) / log (10));
g_signal_emit_by_name (G_OBJECT (GTK_RANGE (widget)->adjustment),
"changed");
widget = glade_xml_get_widget (appdata.xml, "link_width_slider");
gtk_adjustment_set_value (GTK_RANGE (widget)->adjustment,
pref.link_node_ratio);
g_signal_emit_by_name (GTK_OBJECT (GTK_RANGE (widget)->adjustment),
"changed");
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "averaging_spin"));
gtk_spin_button_set_value (spin, pref.averaging_time);
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "refresh_spin"));
gtk_spin_button_set_value (spin, pref.refresh_period);
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "node_to_spin"));
gtk_spin_button_set_value (spin, pref.node_timeout_time/MILLI);
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "gui_node_to_spin"));
gtk_spin_button_set_value (spin, pref.gui_node_timeout_time/MILLI);
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "proto_node_to_spin"));
gtk_spin_button_set_value (spin, pref.proto_node_timeout_time/MILLI);
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "link_to_spin"));
gtk_spin_button_set_value (spin, pref.link_timeout_time/MILLI);
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "gui_link_to_spin"));
gtk_spin_button_set_value (spin, pref.gui_link_timeout_time/MILLI);
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "proto_link_to_spin"));
gtk_spin_button_set_value (spin, pref.proto_link_timeout_time/MILLI);
spin = GTK_SPIN_BUTTON (glade_xml_get_widget (appdata.xml, "proto_to_spin"));
gtk_spin_button_set_value (spin, pref.proto_timeout_time/MILLI);
widget = glade_xml_get_widget (appdata.xml, "diagram_only_toggle");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget),
pref.diagram_only);
widget = glade_xml_get_widget (appdata.xml, "group_unk_check");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), pref.group_unk);
widget = glade_xml_get_widget (appdata.xml, "name_res_check");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), pref.name_res);
widget = glade_xml_get_widget (appdata.xml, "stack_level");
gtk_combo_box_set_active(GTK_COMBO_BOX(widget), pref.stack_level);
widget = glade_xml_get_widget (appdata.xml, "size_variable");
gtk_combo_box_set_active(GTK_COMBO_BOX(widget), pref.node_size_variable);
widget = glade_xml_get_widget (appdata.xml, "size_mode");
gtk_combo_box_set_active(GTK_COMBO_BOX(widget), pref.size_mode);
widget = glade_xml_get_widget (appdata.xml, "text_font");
gtk_font_button_set_font_name(GTK_FONT_BUTTON(widget), pref.fontname);
widget = glade_xml_get_widget (appdata.xml, "text_color");
if (!gdk_color_parse(pref.text_color, &color))
gdk_color_parse("#ffff00", &color);
gtk_color_button_set_color(GTK_COLOR_BUTTON(widget), &color);
widget = glade_xml_get_widget (appdata.xml, "filter_combo");
model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget));
if (!model)
{
GtkListStore *list_store;
list_store=gtk_list_store_new (1, G_TYPE_STRING);
gtk_combo_box_set_model(GTK_COMBO_BOX(widget), GTK_TREE_MODEL(list_store));
}
pref_to_color_list(); /* Updates the color preferences table with pref.colors */
/* Connects signals */
widget = glade_xml_get_widget (appdata.xml, "diag_pref");
g_signal_connect (G_OBJECT (widget),
"delete_event",
GTK_SIGNAL_FUNC
(on_cancel_pref_button_clicked ), NULL);
widget = glade_xml_get_widget (appdata.xml, "node_radius_slider");
g_signal_connect (G_OBJECT (GTK_RANGE (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_node_radius_slider_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "link_width_slider");
g_signal_connect (G_OBJECT (GTK_RANGE (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_link_width_slider_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "averaging_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_averaging_spin_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "refresh_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_refresh_spin_adjustment_changed),
glade_xml_get_widget (appdata.xml, "canvas1"));
widget = glade_xml_get_widget (appdata.xml, "node_to_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_node_to_spin_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "gui_node_to_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_gui_node_to_spin_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "proto_node_to_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_proto_node_to_spin_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "link_to_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_link_to_spin_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "gui_link_to_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_gui_link_to_spin_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "proto_link_to_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_proto_link_to_spin_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "proto_to_spin");
g_signal_connect (G_OBJECT (GTK_SPIN_BUTTON (widget)->adjustment),
"value_changed",
GTK_SIGNAL_FUNC
(on_proto_to_spin_adjustment_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "stack_level");
g_signal_connect (G_OBJECT (widget),
"changed",
GTK_SIGNAL_FUNC (on_stack_level_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "size_variable");
g_signal_connect (G_OBJECT (widget),
"changed",
GTK_SIGNAL_FUNC (on_size_variable_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "size_mode");
g_signal_connect (G_OBJECT (widget),
"changed",
GTK_SIGNAL_FUNC (on_size_mode_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "text_font");
g_signal_connect (G_OBJECT (widget),
"font_set",
GTK_SIGNAL_FUNC (on_text_font_changed), NULL);
widget = glade_xml_get_widget (appdata.xml, "text_color");
g_signal_connect (G_OBJECT (widget),
"color_set",
GTK_SIGNAL_FUNC (on_text_color_changed), NULL);
}
static GtkWidget *
servlist_open_edit (GtkWidget *parent, ircnet *net)
{
GtkWidget *editwindow;
GtkWidget *vbox5;
GtkWidget *table3;
GtkWidget *label17;
GtkWidget *label16;
GtkWidget *label21;
GtkWidget *label22;
GtkWidget *label34;
GtkWidget *comboboxentry_charset;
GtkWidget *hbox1;
GtkWidget *scrolledwindow2;
GtkWidget *treeview_servers;
GtkWidget *vbuttonbox1;
GtkWidget *buttonadd;
GtkWidget *buttonremove;
GtkWidget *buttonedit;
GtkWidget *check;
GtkTreeModel *model;
GtkListStore *store;
GtkCellRenderer *renderer;
char buf[128];
char buf2[128 + 8];
char tbuf[256];
snprintf (tbuf, sizeof tbuf, _("conspire: Network Editor (%s)"), net->name);
editwindow = mg_create_generic_tab(_("Network Editor"), tbuf, FALSE, TRUE, servlist_closegui, NULL, 550, 200, &vbox5, NULL);
table3 = gtk_table_new (17, 3, FALSE);
gtk_widget_show (table3);
gtk_box_pack_start (GTK_BOX (vbox5), table3, TRUE, TRUE, 0);
gtk_table_set_row_spacings (GTK_TABLE (table3), 2);
gtk_table_set_col_spacings (GTK_TABLE (table3), 8);
snprintf (buf, sizeof (buf), _("Servers for %s"), net->name);
snprintf (buf2, sizeof (buf2), "<b>%s</b>", buf);
label16 = gtk_label_new (buf2);
gtk_widget_show (label16);
gtk_table_attach (GTK_TABLE (table3), label16, 0, 3, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 3);
gtk_label_set_use_markup (GTK_LABEL (label16), TRUE);
gtk_misc_set_alignment (GTK_MISC (label16), 0, 0.5);
check = servlist_create_check (0, !(net->flags & FLAG_CYCLE), table3,
2, 1, _("Connect to selected server only"));
add_tip (check, _("Don't cycle through all the servers when the connection fails."));
label17 = bold_label (_("Your Details"));
gtk_table_attach (GTK_TABLE (table3), label17, 0, 3, 3, 4,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 3);
servlist_create_check (1, net->flags & FLAG_USE_GLOBAL, table3,
4, 1, _("Use global user information"));
edit_entry_nick =
servlist_create_entry (table3, _("_Nick name:"), 5, net->nick,
&edit_label_nick, 0);
edit_entry_nick2 =
servlist_create_entry (table3, _("Second choice:"), 6, net->nick2,
&edit_label_nick2, 0);
edit_entry_user =
servlist_create_entry (table3, _("_User name:"), 7, net->user,
&edit_label_user, 0);
edit_entry_real =
servlist_create_entry (table3, _("Rea_l name:"), 8, net->real,
&edit_label_real, 0);
label21 = bold_label (_("Connecting"));
gtk_table_attach (GTK_TABLE (table3), label21, 0, 3, 9, 10,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 3);
servlist_create_check (3, net->flags & FLAG_AUTO_CONNECT, table3,
11, 1, _("Auto connect to this network at startup"));
servlist_create_check (4, net->flags & FLAG_USE_PROXY, table3,
12, 1, _("Use a proxy server"));
edit_entry_join =
servlist_create_entry (table3, _("C_hannels to join:"), 15,
net->autojoin, 0,
_("Channels to join, separated by commas, but not spaces!"));
edit_entry_nickserv =
servlist_create_entry (table3, _("Nickserv password:"******"If your nickname requires a password, enter it here. Not all IRC networks support this."));
gtk_entry_set_visibility (GTK_ENTRY (edit_entry_nickserv), FALSE);
edit_entry_pass =
servlist_create_entry (table3, _("Server password:"******"Password for the server, if in doubt, leave blank."));
gtk_entry_set_visibility (GTK_ENTRY (edit_entry_pass), FALSE);
edit_entry_sasl_user =
servlist_create_entry (table3, _("SASL username:"******"If your network uses SASL, put your username here."));
edit_entry_sasl_pass =
servlist_create_entry (table3, _("SASL password:"******"If your network uses SASL, put your password here."));
gtk_entry_set_visibility (GTK_ENTRY (edit_entry_sasl_pass), FALSE);
label34 = gtk_label_new (_("Character set:"));
gtk_widget_show (label34);
gtk_table_attach (GTK_TABLE (table3), label34, 1, 2, 21, 22,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 0);
gtk_misc_set_alignment (GTK_MISC (label34), 0, 0.5);
comboboxentry_charset = servlist_create_charsetcombo ();
ignore_changed = TRUE;
gtk_entry_set_text (GTK_ENTRY (GTK_BIN (comboboxentry_charset)->child), net->encoding ? net->encoding : "System default");
ignore_changed = FALSE;
gtk_widget_show (comboboxentry_charset);
gtk_table_attach (GTK_TABLE (table3), comboboxentry_charset, 2, 3, 21, 22,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
label22 = bold_label (_("Perform"));
gtk_table_attach (GTK_TABLE (table3), label22, 0, 3, 22, 23,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 3);
edit_entry_cmd =
servlist_create_textview (table3, _("Connect commands:"), 24,
net->command, 0,
_("Extra commands to execute after connecting. Alternatively, to run a large series of commands on connect, use LOAD -e <filename>, where <filename> is a text-file full of commands to execute."));
/*********** FINITO *************/
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_table_attach (GTK_TABLE (table3), hbox1, 1, 3, 1, 2,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow2);
gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2),
GTK_SHADOW_IN);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_BOOLEAN);
model = GTK_TREE_MODEL (store);
edit_tree = treeview_servers = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_widget_show (treeview_servers);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview_servers);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview_servers),
FALSE);
renderer = gtk_cell_renderer_text_new ();
g_signal_connect (G_OBJECT (renderer), "edited",
G_CALLBACK (servlist_editserver_cb), model);
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (treeview_servers), -1,
0, renderer,
"text", 0,
"editable", 1,
NULL);
vbuttonbox1 = gtk_vbutton_box_new ();
gtk_box_set_spacing (GTK_BOX (vbuttonbox1), 3);
gtk_button_box_set_layout (GTK_BUTTON_BOX (vbuttonbox1), GTK_BUTTONBOX_START);
gtk_widget_show (vbuttonbox1);
gtk_box_pack_start (GTK_BOX (hbox1), vbuttonbox1, FALSE, FALSE, 3);
buttonadd = gtk_button_new_from_stock ("gtk-add");
g_signal_connect (G_OBJECT (buttonadd), "clicked",
G_CALLBACK (servlist_addserver_cb), edit_tree);
gtk_widget_show (buttonadd);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonadd);
GTK_WIDGET_SET_FLAGS (buttonadd, GTK_CAN_DEFAULT);
buttonremove = gtk_button_new_from_stock ("gtk-remove");
g_signal_connect (G_OBJECT (buttonremove), "clicked",
G_CALLBACK (servlist_deleteserver_cb), NULL);
gtk_widget_show (buttonremove);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonremove);
GTK_WIDGET_SET_FLAGS (buttonremove, GTK_CAN_DEFAULT);
buttonedit = gtk_button_new_with_mnemonic (_("_Edit"));
g_signal_connect (G_OBJECT (buttonedit), "clicked",
G_CALLBACK (servlist_editserverbutton_cb), NULL);
gtk_widget_show (buttonedit);
gtk_container_add (GTK_CONTAINER (vbuttonbox1), buttonedit);
GTK_WIDGET_SET_FLAGS (buttonedit, GTK_CAN_DEFAULT);
if (net->flags & FLAG_USE_GLOBAL)
{
gtk_widget_hide (edit_label_nick);
gtk_widget_hide (edit_entry_nick);
gtk_widget_hide (edit_label_nick2);
gtk_widget_hide (edit_entry_nick2);
gtk_widget_hide (edit_label_user);
gtk_widget_hide (edit_entry_user);
gtk_widget_hide (edit_label_real);
gtk_widget_hide (edit_entry_real);
}
return editwindow;
}
void SetupHashWindow()
{
/* Setup window */
gui.windows.hash = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(gui.windows.hash), "Hashes");
gtk_window_set_default_size(GTK_WINDOW(gui.windows.hash), 580, 340);
gtk_window_set_deletable(GTK_WINDOW(gui.windows.hash), false);
gui.fixed.hash = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(gui.windows.hash), gui.fixed.hash);
/* Load hashes */
gui.entries.hash = gtk_entry_new();
gtk_widget_set_size_request(gui.entries.hash, 380, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.entries.hash, 8, 8);
gui.cbox.hash = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hashlist");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Hash");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "pwdump");
gtk_combo_box_append_text(GTK_COMBO_BOX(gui.cbox.hash), "Cain");
gtk_widget_set_size_request(gui.cbox.hash, 90, 32);
gtk_combo_box_set_active(GTK_COMBO_BOX(gui.cbox.hash), 0);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.cbox.hash, 390, 8);
gui.buttons.hash_load = gtk_button_new_with_label("Load");
gtk_widget_set_size_request(gui.buttons.hash_load, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_load, 485, 8);
/* TreeView */
gui.hash.scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(gui.hash.scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gui.hash.tree = gtk_tree_view_new();
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(gui.hash.tree), true);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(gui.hash.tree), true);
gui.hash.store = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(gui.hash.tree), GTK_TREE_MODEL(gui.hash.store));
gui.hash.render = gtk_cell_renderer_text_new();
GtkTreeViewColumn *col = gtk_tree_view_column_new_with_attributes("Algorithm", gui.hash.render, "text", 0, NULL);
gtk_tree_view_column_set_sort_column_id(col, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
col = gtk_tree_view_column_new_with_attributes("Length", gui.hash.render, "text", 1, NULL);
gtk_tree_view_column_set_sort_column_id(col, 1);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
col = gtk_tree_view_column_new_with_attributes("Hash", gui.hash.render, "text", 2, NULL);
gtk_tree_view_column_set_sort_column_id(col, 2);
gtk_tree_view_append_column(GTK_TREE_VIEW(gui.hash.tree), col);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(gui.hash.tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_container_add(GTK_CONTAINER(gui.hash.scroll), gui.hash.tree);
gtk_widget_set_size_request(gui.hash.tree, 560, 240);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.hash.scroll, 8, 48);
/* Buttons */
gui.buttons.hash_delete = gtk_button_new_with_label("Remove");
gtk_widget_set_size_request(gui.buttons.hash_delete, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_delete, 8, 300);
gui.buttons.hash_clear = gtk_button_new_with_label("Clear");
gtk_widget_set_size_request(gui.buttons.hash_clear, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_clear, 100, 300);
gui.buttons.hash_ok = gtk_button_new_with_label("OK");
gtk_widget_set_size_request(gui.buttons.hash_ok, 80, 32);
gtk_fixed_put(GTK_FIXED(gui.fixed.hash), gui.buttons.hash_ok, 480, 300);
g_signal_connect(gui.buttons.hash_load, "clicked", G_CALLBACK(LoadHashes), NULL);
g_signal_connect(gui.buttons.hash_ok, "clicked", G_CALLBACK(HideHashWindow), NULL);
g_signal_connect(gui.buttons.hash_delete, "clicked", G_CALLBACK(DeleteHashes), NULL);
g_signal_connect(gui.buttons.hash_clear, "clicked", G_CALLBACK(ClearHashes), NULL);
return;
}
static void
gxi_update_string_box (GncXmlImportData *data)
{
gchar *string;
const gchar *utf8;
GtkBox *vbox;
GtkComboBox *combo;
GtkListStore *store;
GList *word_iter, *conv_iter;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GQuark chosen_encoding;
GtkTreeIter *chosen_iter, *default_iter;
ambiguous_type *amb;
conv_type *conv;
if (data->string_box)
gtk_widget_destroy (data->string_box);
data->string_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_set_homogeneous (GTK_BOX (data->string_box), FALSE);
vbox = GTK_BOX (data->string_box);
data->n_unassigned = 0;
/* loop through words */
for (word_iter = data->ambiguous_list; word_iter; word_iter = word_iter->next)
{
store = gtk_list_store_new (WORD_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER);
combo = GTK_COMBO_BOX (gtk_combo_box_new_with_model (
GTK_TREE_MODEL (store)));
g_object_unref (store);
renderer = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (combo), renderer, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (combo), renderer,
"text", WORD_COL_STRING, NULL);
/* add default string, if possible */
amb = (ambiguous_type*) word_iter->data;
utf8 = get_decoded_string (amb, data->default_encoding);
default_iter = NULL;
if (utf8)
{
string = g_strdup_printf ("%s (default)", utf8);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, WORD_COL_STRING, string,
WORD_COL_ENCODING,
GUINT_TO_POINTER (data->default_encoding), -1);
g_free (string);
default_iter = gtk_tree_iter_copy (&iter);
}
/* user has selected this previously */
conv = (conv_type*) g_hash_table_lookup (data->choices, amb->byte_sequence);
chosen_encoding = (conv) ? conv->encoding : 0;
chosen_iter = NULL;
/* loop through conversions */
for (conv_iter = amb->conv_list; conv_iter; conv_iter = conv_iter->next)
{
conv = (conv_type*) conv_iter->data;
string = g_strdup_printf ("%s (%s)", conv->utf8_string,
g_quark_to_string (conv->encoding));
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter, WORD_COL_STRING, string,
WORD_COL_ENCODING,
GUINT_TO_POINTER (conv->encoding), -1);
g_free (string);
if (chosen_encoding && conv->encoding == chosen_encoding)
{
chosen_iter = gtk_tree_iter_copy (&iter);
}
} /* next conversion */
if (chosen_iter)
{
/* select previous selection again, are not we cute */
gtk_combo_box_set_active_iter (combo, chosen_iter);
gtk_tree_iter_free (chosen_iter);
}
else
{
if (default_iter)
{
/* select default entry */
gtk_combo_box_set_active_iter (combo, default_iter);
}
else
{
/* count it */
data->n_unassigned++;
}
}
/* wire up combo */
g_object_set_data (G_OBJECT (combo), "ambiguous", amb);
g_signal_connect (G_OBJECT (combo), "changed",
G_CALLBACK (gxi_string_combo_changed_cb), data);
gtk_box_pack_start (vbox, GTK_WIDGET (combo), FALSE, FALSE, 0);
gtk_widget_show (GTK_WIDGET (combo));
} /* next word */
/* wire up whole string vbox */
gtk_container_add (GTK_CONTAINER (data->string_box_container), GTK_WIDGET (vbox));
gtk_widget_show (GTK_WIDGET (vbox));
/* update label now, n_unassigned is calculated */
if (!data->summary_label)
data->summary_label = data->impossible_label;
gxi_update_summary_label (data);
}
void usldoks_create_list (class usldoks_data *data)
{
class iceb_gdite_data gdite;
iceb_gdite(&gdite,0,data->window);
GtkListStore *model=NULL;
GtkTreeIter iter;
SQLCURSOR cur;
SQLCURSOR cur1;
char strsql[512];
char bros[500];
int kolstr=0;
SQL_str row;
iceb_u_str zagolov;
data->kl_shift=0; //0-отжата 1-нажата
gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
iceb_refresh();
if(data->treeview != NULL)
gtk_widget_destroy(data->treeview);
data->treeview = gtk_tree_view_new();
gtk_container_add (GTK_CONTAINER (data->sw), data->treeview);
g_signal_connect(data->treeview,"row_activated",G_CALLBACK(usldoks_v_row),data);
GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview));
gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE);
g_signal_connect(selection,"changed",G_CALLBACK(usldoks_vibor),data);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE);
model = gtk_list_store_new (NUM_COLUMNS+1,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT);
sprintf(bros,"tp,datd,podr,kontr,nomd,nomnn,kodop,pod,pro,ktoi,nomdp,vrem,dover,nds,sumkor,sumnds,pn,mo from Usldokum");
sprintf(strsql,"select %s where datd >= '%d-01-01' order by datd asc",
bros,data->gn);
if(data->dn != 0)
sprintf(strsql,"select %s where datd >= '%d-%02d-%02d' order by datd asc",
bros,data->gn,data->mn,data->dn);
if(data->dn != 0 && data->dk != 0)
sprintf(strsql,"select %s where datd >= '%d-%02d-%02d' and datd <= '%d-%02d-%02d' \
order by datd asc",bros,data->gn,data->mn,data->dn,data->gk,data->mk,data->dk);
data->zapros.new_plus(strsql);
if((kolstr=cur.make_cursor(&bd,strsql)) < 0)
{
iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window);
return;
}
//gtk_list_store_clear(model);
iceb_u_str ss[NUM_COLUMNS];
data->kolzap=0;
float kolstr1=0.;
while(cur.read_cursor(&row) != 0)
{
iceb_pbar(gdite.bar,kolstr,++kolstr1);
// printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]);
if(usldoks_prov_row(row,data) != 0)
continue;
//Метка записи
ss[COL_METKAZ].new_plus("");
if(row[0][0] == '1')
ss[COL_METKAZ].new_plus("+");
else
ss[COL_METKAZ].new_plus("-");
if(row[7][0] == '0')
ss[COL_METKAZ].plus("?");
if(row[8][0] == '0')
ss[COL_METKAZ].plus("*");
if(row[17][0] == '0')
ss[COL_METKAZ].plus("$");
//Дата документа
ss[COL_DATAD].new_plus(iceb_u_sqldata(row[1]));
//Номер документа
ss[COL_NOMDOK].new_plus(iceb_u_toutf(row[4]));
//Контрагент
ss[COL_KONTR].new_plus(iceb_u_toutf(row[3]));
//Код операции
ss[COL_KODOP].new_plus(iceb_u_toutf(row[6]));
//код подразделения
ss[COL_PODR].new_plus(iceb_u_toutf(row[2]));
//Номер налоговой накладной
ss[COL_NOMNALNAK].new_plus(iceb_u_toutf(row[5]));
//Номер накладной парного документа
ss[COL_NOMPD].new_plus(iceb_u_toutf(row[10]));
//Дата и время записи
ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[11])));
//Кто записал
ss[COL_KTO].new_plus(iceb_kszap(row[9],0,data->window));
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COL_METKAZ,ss[COL_METKAZ].ravno(),
COL_DATAD,ss[COL_DATAD].ravno(),
COL_NOMDOK,ss[COL_NOMDOK].ravno(),
COL_KONTR,ss[COL_KONTR].ravno(),
COL_KODOP,ss[COL_KODOP].ravno(),
COL_PODR,ss[COL_PODR].ravno(),
COL_NOMNALNAK,ss[COL_NOMNALNAK].ravno(),
COL_NOMPD,ss[COL_NOMPD].ravno(),
COL_DATA_VREM,ss[COL_DATA_VREM].ravno(),
COL_KTO,ss[COL_KTO].ravno(),
NUM_COLUMNS,data->kolzap,
-1);
data->kolzap++;
}
gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model));
g_object_unref (GTK_TREE_MODEL (model));
usldoks_add_columns (GTK_TREE_VIEW (data->treeview));
if(data->kolzap == 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK3]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),FALSE);//Недоступна
}
else
{
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK3]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK6]),TRUE);//Доступна
}
gtk_widget_show (data->treeview);
gtk_widget_show (data->sw);
if(data->kolzap > 0)
{
if(data->snanomer > data->kolzap-1)
data->snanomer= data->kolzap-1;
if(data->snanomer < 0)
data->snanomer=0;
printf("poz=%d\n",data->snanomer);
sprintf(strsql,"%d",data->snanomer);
GtkTreePath *path=gtk_tree_path_new_from_string(strsql);
// gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (data->treeview),path,NULL,TRUE,0,0);
gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW (data->treeview),path,NULL,FALSE,0,0);
gtk_tree_view_set_cursor(GTK_TREE_VIEW (data->treeview),path,NULL,FALSE);
gtk_tree_path_free(path);
// data->snanomer=-2;
}
iceb_u_str strpoi;
strpoi.plus("");
if(data->poi.metka_pros == 1)
strpoi.new_plus(gettext("Просмотр только неподтверждённых документов"));
if(data->poi.metka_pros == 2)
strpoi.new_plus(gettext("Просмотр только документов без проводок"));
if(data->poi.metka_poi == 1 || data->poi.metka_opl != 0)
{
// printf("Формирование заголовка с реквизитами поиска.\n");
if(data->poi.metka_pros != 0)
strpoi.ps_plus(gettext("Поиск"));
else
strpoi.new_plus(gettext("Поиск"));
strpoi.plus(" !!!");
iceb_str_poisk(&strpoi,data->poi.nomdok.ravno(),gettext("Номер документа"));
iceb_str_poisk(&strpoi,data->poi.datan.ravno(),gettext("Дата начала"));
iceb_str_poisk(&strpoi,data->poi.datak.ravno(),gettext("Дата конца"));
iceb_str_poisk(&strpoi,data->poi.kontr.ravno(),gettext("Код контрагента"));
iceb_str_poisk(&strpoi,data->poi.naim_kontr.ravno(),gettext("Наименование контрагента"));
iceb_str_poisk(&strpoi,data->poi.kodop.ravno(),gettext("Код операции"));
iceb_str_poisk(&strpoi,data->poi.kodpod.ravno(),gettext("Код подразделения"));
iceb_str_poisk(&strpoi,data->poi.nalnak.ravno(),gettext("Номер налоговой накладной"));
iceb_str_poisk(&strpoi,data->poi.dover.ravno(),gettext("Доверенность"));
if(data->poi.pr_ras.ravno_pr() == 1)
strpoi.ps_plus(gettext("Только приходы"));
if(data->poi.pr_ras.ravno_pr() == 2)
strpoi.ps_plus(gettext("Только расходы"));
if(data->poi.metka_opl == 1)
strpoi.ps_plus(gettext("Только оплаченные"));
if(data->poi.metka_opl == 2)
strpoi.ps_plus(gettext("Только неоплаченные"));
}
if(strpoi.getdlinna() > 1)
{
gtk_label_set_text(GTK_LABEL(data->label_poisk),strpoi.ravno_toutf());
gtk_widget_show(data->label_poisk);
}
else
gtk_widget_hide(data->label_poisk);
zagolov.new_plus(gettext("Список документов"));
sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap);
zagolov.plus(strsql);
gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf());
gtk_widget_show(data->label_kolstr);
gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR));
}
NewStylesheetDialog::NewStylesheetDialog(const ustring & worksheet, GtkWindow *transient_parent)
{
myworksheet = worksheet;
Shortcuts shortcuts(0);
newstylesheetdialog = gtk_dialog_new();
gtk_window_set_transient_for(GTK_WINDOW(newstylesheetdialog), transient_parent);
if (!worksheet.empty()) {
gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New style"));
}
else {
gtk_window_set_title(GTK_WINDOW(newstylesheetdialog), _("New stylesheet"));
}
//gtk_window_set_position(GTK_WINDOW(newstylesheetdialog), GTK_WIN_POS_CENTER_ON_PARENT);
dialog_vbox1 = gtk_dialog_get_content_area (GTK_DIALOG (newstylesheetdialog));
gtk_widget_show(dialog_vbox1);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX(dialog_vbox1), hbox2, TRUE, TRUE, 0);
vbox1 = gtk_vbox_new(FALSE, 4);
gtk_widget_show(vbox1);
gtk_box_pack_start(GTK_BOX(hbox2), vbox1, TRUE, TRUE, 0);
if (myworksheet.empty()) {
hbox1 = gtk_hbox_new(FALSE, 4);
gtk_widget_show(hbox1);
gtk_box_pack_start(GTK_BOX(vbox1), hbox1, TRUE, TRUE, 0);
label1 = gtk_label_new(_("Name"));
gtk_widget_show(label1);
gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0);
shortcuts.label(label1);
entry1 = gtk_entry_new();
gtk_widget_show(entry1);
gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0);
}
ustring info;
if (!myworksheet.empty())
info = _("Select one or more styles from the list");
label_info = gtk_label_new(info.c_str());
gtk_widget_show(label_info);
gtk_box_pack_start(GTK_BOX(vbox1), label_info, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(label_info), 0, 0.5);
GSList *radiobutton_basic_group = NULL;
radiobutton_basic = gtk_radio_button_new_with_mnemonic(NULL, _("Basic"));
gtk_widget_show(radiobutton_basic);
gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_basic, FALSE, FALSE, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_basic), radiobutton_basic_group);
radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_basic));
shortcuts.button(radiobutton_basic);
radiobutton_paragraph = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph"));
gtk_widget_show(radiobutton_paragraph);
gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_paragraph, FALSE, FALSE, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_paragraph), radiobutton_basic_group);
radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_paragraph));
shortcuts.button(radiobutton_paragraph);
radiobutton_word_note = gtk_radio_button_new_with_mnemonic(NULL, _("Basic, paragraph, word, note"));
gtk_widget_show(radiobutton_word_note);
gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_word_note, FALSE, FALSE, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_word_note), radiobutton_basic_group);
radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_word_note));
shortcuts.button(radiobutton_word_note);
radiobutton_sbp = gtk_radio_button_new_with_mnemonic(NULL, _("SIL best practice"));
gtk_widget_show(radiobutton_sbp);
gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_sbp, FALSE, FALSE, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_sbp), radiobutton_basic_group);
radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_sbp));
shortcuts.button(radiobutton_sbp);
radiobutton_full = gtk_radio_button_new_with_mnemonic(NULL, _("Full"));
gtk_widget_show(radiobutton_full);
gtk_box_pack_start(GTK_BOX(vbox1), radiobutton_full, FALSE, FALSE, 0);
gtk_radio_button_set_group(GTK_RADIO_BUTTON(radiobutton_full), radiobutton_basic_group);
radiobutton_basic_group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(radiobutton_full));
shortcuts.button(radiobutton_full);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radiobutton_full), true);
if (!myworksheet.empty()) {
expander1 = gtk_expander_new(NULL);
gtk_widget_show(expander1);
gtk_box_pack_start(GTK_BOX(vbox1), expander1, TRUE, TRUE, 0);
label2 = gtk_label_new(_("Add non-standard style"));
gtk_widget_show(label2);
gtk_expander_set_label_widget(GTK_EXPANDER(expander1), label2);
shortcuts.label(label2);
hbox1 = gtk_hbox_new(FALSE, 4);
gtk_widget_show(hbox1);
gtk_container_add(GTK_CONTAINER(expander1), hbox1);
label1 = gtk_label_new(_("Name"));
gtk_widget_show(label1);
gtk_box_pack_start(GTK_BOX(hbox1), label1, FALSE, FALSE, 0);
shortcuts.label(label1);
entry1 = gtk_entry_new();
gtk_widget_show(entry1);
gtk_box_pack_start(GTK_BOX(hbox1), entry1, TRUE, TRUE, 0);
scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow1);
gtk_box_pack_start(GTK_BOX(hbox2), scrolledwindow1, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
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);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview1), FALSE);
store1 = gtk_list_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview1), GTK_TREE_MODEL(store1));
g_object_unref(store1);
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
column1 = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview1), column1);
select1 = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview1));
gtk_tree_selection_set_mode(select1, GTK_SELECTION_SINGLE);
}
dialog_action_area1 = gtk_dialog_get_action_area (GTK_DIALOG(newstylesheetdialog));
gtk_widget_show(dialog_action_area1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END);
new InDialogHelp(newstylesheetdialog, NULL, &shortcuts, "file/styles/stylesheet/new");
cancelbutton1 = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton1);
gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), cancelbutton1, GTK_RESPONSE_CANCEL);
gtk_widget_set_can_default (GTK_WIDGET (cancelbutton1), true);
okbutton = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton);
gtk_dialog_add_action_widget(GTK_DIALOG(newstylesheetdialog), okbutton, GTK_RESPONSE_OK);
gtk_widget_set_can_default (GTK_WIDGET (okbutton), true);
shortcuts.stockbutton(cancelbutton1);
shortcuts.stockbutton(okbutton);
shortcuts.process();
g_signal_connect((gpointer) entry1, "changed", G_CALLBACK(on_entry_changed), gpointer(this));
g_signal_connect((gpointer) radiobutton_basic, "toggled", G_CALLBACK(on_radiobutton_basic_toggled), gpointer(this));
g_signal_connect((gpointer) radiobutton_paragraph, "toggled", G_CALLBACK(on_radiobutton_paragraph_toggled), gpointer(this));
g_signal_connect((gpointer) radiobutton_word_note, "toggled", G_CALLBACK(on_radiobutton_word_note_toggled), gpointer(this));
g_signal_connect((gpointer) radiobutton_sbp, "toggled", G_CALLBACK(on_radiobutton_sbp_toggled), gpointer(this));
g_signal_connect((gpointer) radiobutton_full, "toggled", G_CALLBACK(on_radiobutton_full_toggled), gpointer(this));
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
gtk_widget_grab_focus(entry1);
gtk_widget_grab_default(okbutton);
gtk_label_set_mnemonic_widget(GTK_LABEL(label1), entry1);
on_entry();
on_radiobutton();
}
GtkWidget *Create_Log_Area (void)
{
GtkWidget *Frame;
GtkWidget *ScrollWindowLogList;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkWidget *PopupMenu;
Frame = gtk_frame_new(_("Log"));
gtk_container_set_border_width(GTK_CONTAINER(Frame), 2);
/*
* The ScrollWindow and the List
*/
ScrollWindowLogList = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowLogList),
GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(Frame),ScrollWindowLogList);
/* The file list */
logListModel = gtk_list_store_new(LOG_COLUMN_COUNT,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
GDK_TYPE_COLOR,
GDK_TYPE_COLOR);
LogList = gtk_tree_view_new_with_model(GTK_TREE_MODEL(logListModel));
g_object_unref (logListModel);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(LogList), FALSE);
gtk_container_add(GTK_CONTAINER(ScrollWindowLogList), LogList);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(LogList), FALSE);
gtk_widget_set_size_request(LogList, 0, 0);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(LogList), FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(LogList)),GTK_SELECTION_MULTIPLE);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(LogList), column);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"stock-id", LOG_PIXBUF,
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", LOG_TIME_TEXT,
"background-gdk", LOG_ROW_BACKGROUND,
"foreground-gdk", LOG_ROW_FOREGROUND,
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", LOG_TEXT,
"background-gdk", LOG_ROW_BACKGROUND,
"foreground-gdk", LOG_ROW_FOREGROUND,
NULL);
// Create Popup Menu on browser album list
PopupMenu = gtk_ui_manager_get_widget(UIManager, "/LogPopup");
gtk_menu_attach_to_widget (GTK_MENU (PopupMenu), LogList, NULL);
g_signal_connect (G_OBJECT (LogList), "button-press-event",
G_CALLBACK (Log_Popup_Menu_Handler), PopupMenu);
// Load pending messages in the Log list
Log_Print_Tmp_List();
if (SHOW_LOG_VIEW)
//gtk_widget_show_all(ScrollWindowLogList);
gtk_widget_show_all(Frame);
//return ScrollWindowLogList;
return Frame;
}
static GtkWidget *create_window(void)
{
// Basic window
stwidgets.startwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(stwidgets.startwin), apptitle); // NOTE: use global app title
gtk_window_set_position(GTK_WINDOW(stwidgets.startwin), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(stwidgets.startwin), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(stwidgets.startwin), GDK_WINDOW_TYPE_HINT_DIALOG);
// Horizontal layout of banner and controls
stwidgets.hlayout = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startwin), stwidgets.hlayout);
// banner
{
GdkPixbuf *pixbuf = load_banner();
stwidgets.banner = gtk_image_new_from_pixbuf(pixbuf);
g_object_unref((gpointer)pixbuf);
}
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.banner, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(stwidgets.banner), 0.5, 0);
// Vertical layout of tab control and start+cancel buttons
stwidgets.vlayout = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(stwidgets.hlayout), stwidgets.vlayout, TRUE, TRUE, 0);
// Tab control
stwidgets.tabs = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.tabs, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.tabs), 4);
// layout table of config page
stwidgets.configtlayout = gtk_table_new(6, 3, FALSE);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.configtlayout);
// 3D video mode LabelText
stwidgets.vmode3dlabel = gtk_label_new_with_mnemonic("_Video mode:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.vmode3dlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dlabel, 0,1, 0,1, GTK_FILL, 0, 4, 0);
// 3D video mode combo
{
GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
GtkCellRenderer *cell;
stwidgets.vmode3dcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.vmode3dcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.vmode3dcombo, 1,2, 0,1, GTK_EXPAND | GTK_FILL, 0, 4, 0);
// Fullscreen checkbox
stwidgets.displayvlayout = gtk_vbox_new(TRUE, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.displayvlayout, 2,3, 0,1, GTK_FILL, 0, 4, 0);
stwidgets.fullscreencheck = gtk_check_button_new_with_mnemonic("_Fullscreen");
gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.fullscreencheck, FALSE, FALSE, 0);
#ifdef POLYMER
// Polymer checkbox
stwidgets.polymercheck = gtk_check_button_new_with_mnemonic("_Polymer");
gtk_box_pack_start(GTK_BOX(stwidgets.displayvlayout), stwidgets.polymercheck, FALSE, FALSE, 0);
#endif
// Input devices LabelText
stwidgets.inputdevlabel = gtk_label_new_with_mnemonic("_Input devices:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.inputdevlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevlabel, 0,1, 1,2, GTK_FILL, 0, 4, 0);
// Input devices combo
{
GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING);
GtkCellRenderer *cell;
stwidgets.inputdevcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.inputdevcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.inputdevcombo, 1,2, 1,2, GTK_EXPAND | GTK_FILL, 0, 4, 0);
// Custom mod LabelText
stwidgets.custommodlabel = gtk_label_new_with_mnemonic("Custom _game:");
gtk_misc_set_alignment(GTK_MISC(stwidgets.custommodlabel), 0.3, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodlabel, 0,1, 2,3, GTK_FILL, 0, 4, 7);
// Custom mod combo
{
GtkListStore *list = gtk_list_store_new(1, G_TYPE_STRING);
GtkCellRenderer *cell;
stwidgets.custommodcombo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(stwidgets.custommodcombo), cell, "text", 0, NULL);
}
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.custommodcombo, 1,2, 2,3, GTK_EXPAND | GTK_FILL, 0, 4, 7);
// Empty horizontal layout
stwidgets.emptyhlayout = gtk_hbox_new(TRUE, 0);
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.emptyhlayout, 0,3, 3,4, 0, GTK_EXPAND | GTK_FILL, 4, 0);
// Autoload checkbox
stwidgets.autoloadcheck = gtk_check_button_new_with_mnemonic("_Enable \"autoload\" folder");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.autoloadcheck, 0,3, 4,5, GTK_FILL, 0, 2, 2);
// Always show config checkbox
stwidgets.alwaysshowcheck = gtk_check_button_new_with_mnemonic("_Always show this window at startup");
gtk_table_attach(GTK_TABLE(stwidgets.configtlayout), stwidgets.alwaysshowcheck, 0,3, 5,6, GTK_FILL, 0, 2, 2);
// Configuration tab
stwidgets.configtab = gtk_label_new("Configuration");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 0), stwidgets.configtab);
// Game data layout
stwidgets.gamevlayout = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.gamevlayout);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.gamevlayout), 4);
// Game data field LabelText
stwidgets.gamelabel = gtk_label_new_with_mnemonic("_Game:");
gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamelabel, FALSE, FALSE, 0);
gtk_misc_set_alignment(GTK_MISC(stwidgets.gamelabel), 0, 0.5);
// Game data scrollable area
stwidgets.gamescroll = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(stwidgets.gamevlayout), stwidgets.gamescroll, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(stwidgets.gamescroll), GTK_SHADOW_IN);
// Game data list
{
GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING);
stwidgets.gamelist = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
g_object_unref(G_OBJECT(list));
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col);
col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL);
gtk_tree_view_column_set_min_width(col, 64);
gtk_tree_view_append_column(GTK_TREE_VIEW(stwidgets.gamelist), col);
}
gtk_container_add(GTK_CONTAINER(stwidgets.gamescroll), stwidgets.gamelist);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(stwidgets.gamelist), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(stwidgets.gamelist), FALSE);
// Game tab
stwidgets.gametab = gtk_label_new("Game");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 1), stwidgets.gametab);
// Messages scrollable area
stwidgets.messagesscroll = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(stwidgets.tabs), stwidgets.messagesscroll);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(stwidgets.messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// Messages text area
stwidgets.messagestext = gtk_text_view_new();
gtk_container_add(GTK_CONTAINER(stwidgets.messagesscroll), stwidgets.messagestext);
gtk_text_view_set_editable(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(stwidgets.messagestext), GTK_WRAP_WORD);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(stwidgets.messagestext), FALSE);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(stwidgets.messagestext), 2);
// Messages tab
stwidgets.messagestab = gtk_label_new("Messages");
gtk_notebook_set_tab_label(GTK_NOTEBOOK(stwidgets.tabs), gtk_notebook_get_nth_page(GTK_NOTEBOOK(stwidgets.tabs), 2), stwidgets.messagestab);
// Dialogue box buttons layout
stwidgets.buttons = gtk_hbutton_box_new();
gtk_box_pack_start(GTK_BOX(stwidgets.vlayout), stwidgets.buttons, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(stwidgets.buttons), 3);
gtk_button_box_set_layout(GTK_BUTTON_BOX(stwidgets.buttons), GTK_BUTTONBOX_END);
// Cancel button
stwidgets.cancelbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.cancelbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.cancelbutton, GTK_CAN_DEFAULT);
stwidgets.cancelbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbutton), stwidgets.cancelbuttonalign);
stwidgets.cancelbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.cancelbuttonalign), stwidgets.cancelbuttonlayout);
stwidgets.cancelbuttonicon = gtk_image_new_from_stock("gtk-cancel", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonicon, FALSE, FALSE, 0);
stwidgets.cancelbuttonlabel = gtk_label_new_with_mnemonic("_Cancel");
gtk_box_pack_start(GTK_BOX(stwidgets.cancelbuttonlayout), stwidgets.cancelbuttonlabel, FALSE, FALSE, 0);
// Start button
stwidgets.startbutton = gtk_button_new();
gtk_container_add(GTK_CONTAINER(stwidgets.buttons), stwidgets.startbutton);
GTK_WIDGET_SET_FLAGS(stwidgets.startbutton, GTK_CAN_DEFAULT);
gtk_window_set_default(GTK_WINDOW(stwidgets.startwin), stwidgets.startbutton);
stwidgets.startbuttonalign = gtk_alignment_new(0.5, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(stwidgets.startbutton), stwidgets.startbuttonalign);
stwidgets.startbuttonlayout = gtk_hbox_new(FALSE, 2);
gtk_container_add(GTK_CONTAINER(stwidgets.startbuttonalign), stwidgets.startbuttonlayout);
stwidgets.startbuttonicon = gtk_image_new_from_stock("gtk-execute", GTK_ICON_SIZE_BUTTON);
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonicon, FALSE, FALSE, 0);
stwidgets.startbuttonlabel = gtk_label_new_with_mnemonic("_Start");
gtk_box_pack_start(GTK_BOX(stwidgets.startbuttonlayout), stwidgets.startbuttonlabel, FALSE, FALSE, 0);
// Wire up the signals
g_signal_connect((gpointer) stwidgets.startwin, "delete_event",
G_CALLBACK(on_startwin_delete_event),
NULL);
g_signal_connect((gpointer) stwidgets.vmode3dcombo, "changed",
G_CALLBACK(on_vmode3dcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.fullscreencheck, "toggled",
G_CALLBACK(on_fullscreencheck_toggled),
NULL);
#ifdef POLYMER
g_signal_connect((gpointer) stwidgets.polymercheck, "toggled",
G_CALLBACK(on_polymercheck_toggled),
NULL);
#endif
g_signal_connect((gpointer) stwidgets.inputdevcombo, "changed",
G_CALLBACK(on_inputdevcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.custommodcombo, "changed",
G_CALLBACK(on_custommodcombo_changed),
NULL);
g_signal_connect((gpointer) stwidgets.autoloadcheck, "toggled",
G_CALLBACK(on_autoloadcheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.alwaysshowcheck, "toggled",
G_CALLBACK(on_alwaysshowcheck_toggled),
NULL);
g_signal_connect((gpointer) stwidgets.cancelbutton, "clicked",
G_CALLBACK(on_cancelbutton_clicked),
NULL);
g_signal_connect((gpointer) stwidgets.startbutton, "clicked",
G_CALLBACK(on_startbutton_clicked),
NULL);
{
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(stwidgets.gamelist));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
g_signal_connect((gpointer) sel, "changed",
G_CALLBACK(on_gamelist_selection_changed),
NULL);
}
// Associate labels with their controls
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.vmode3dlabel), stwidgets.vmode3dcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.inputdevlabel), stwidgets.inputdevcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.custommodlabel), stwidgets.custommodcombo);
gtk_label_set_mnemonic_widget(GTK_LABEL(stwidgets.gamelabel), stwidgets.gamelist);
return stwidgets.startwin;
}
static void setup_dialog(GtkBuilder* builder, PagerData* pager)
{
gboolean value;
GtkTreeViewColumn* column;
GtkCellRenderer* cell;
int nr_ws, i;
pager->workspaces_frame = WID("workspaces_frame");
pager->workspace_names_label = WID("workspace_names_label");
pager->workspace_names_scroll = WID("workspace_names_scroll");
pager->display_workspaces_toggle = WID("workspace_name_toggle");
setup_sensitivity(pager, builder, "workspace_name_toggle", NULL, NULL, "display_workspace_names" /* key */);
pager->all_workspaces_radio = WID("all_workspaces_radio");
pager->current_only_radio = WID("current_only_radio");
setup_sensitivity(pager, builder, "all_workspaces_radio", "current_only_radio", "label_row_col", "display_all_workspaces" /* key */);
pager->num_rows_spin = WID("num_rows_spin");
pager->label_row_col = WID("label_row_col");
setup_sensitivity(pager, builder, "num_rows_spin", NULL, NULL, "num_rows" /* key */);
pager->num_workspaces_spin = WID("num_workspaces_spin");
setup_sensitivity(pager, builder, "num_workspaces_spin", NULL, NULL, NUM_WORKSPACES /* key */);
pager->workspaces_tree = WID("workspaces_tree_view");
setup_sensitivity(pager, builder, "workspaces_tree_view", NULL, NULL, WORKSPACE_NAME /* key */);
/* Display workspace names: */
g_signal_connect(G_OBJECT(pager->display_workspaces_toggle), "toggled", (GCallback) display_workspace_names_toggled, pager);
if (pager->display_mode == MATEWNCK_PAGER_DISPLAY_NAME)
{
value = TRUE;
}
else
{
value = FALSE;
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->display_workspaces_toggle), value);
/* Display all workspaces: */
g_signal_connect(G_OBJECT(pager->all_workspaces_radio), "toggled", (GCallback) all_workspaces_toggled, pager);
if (pager->display_all)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->all_workspaces_radio), TRUE);
if (!g_object_get_data(G_OBJECT(pager->num_rows_spin), NEVER_SENSITIVE))
{
gtk_widget_set_sensitive(pager->num_rows_spin, TRUE);
}
}
else
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pager->current_only_radio), TRUE);
gtk_widget_set_sensitive(pager->num_rows_spin, FALSE);
}
/* Num rows: */
g_signal_connect(G_OBJECT(pager->num_rows_spin), "value_changed", (GCallback) num_rows_value_changed, pager);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(pager->num_rows_spin), pager->n_rows);
gtk_label_set_text(GTK_LABEL(pager->label_row_col), pager->orientation == GTK_ORIENTATION_HORIZONTAL ? _("rows") : _("columns"));
g_signal_connect(pager->properties_dialog, "destroy", G_CALLBACK(properties_dialog_destroyed), pager);
g_signal_connect(pager->properties_dialog, "delete_event", G_CALLBACK(delete_event), pager);
g_signal_connect(pager->properties_dialog, "response", G_CALLBACK(response_cb), pager);
g_signal_connect(WID("done_button"), "clicked", (GCallback) close_dialog, pager);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(pager->num_workspaces_spin), matewnck_screen_get_workspace_count(pager->screen));
g_signal_connect(G_OBJECT(pager->num_workspaces_spin), "value_changed", (GCallback) num_workspaces_value_changed, pager);
wncklet_connect_while_alive(pager->screen, "workspace_created", G_CALLBACK(workspace_created), pager, pager->properties_dialog);
wncklet_connect_while_alive(pager->screen, "workspace_destroyed", G_CALLBACK(workspace_destroyed), pager, pager->properties_dialog);
g_signal_connect(G_OBJECT(pager->workspaces_tree), "focus_out_event", (GCallback) workspaces_tree_focused_out, pager);
pager->workspaces_store = gtk_list_store_new(1, G_TYPE_STRING, NULL);
update_workspaces_model(pager);
gtk_tree_view_set_model(GTK_TREE_VIEW(pager->workspaces_tree), GTK_TREE_MODEL(pager->workspaces_store));
g_object_unref(pager->workspaces_store);
cell = g_object_new(GTK_TYPE_CELL_RENDERER_TEXT, "editable", TRUE, NULL);
column = gtk_tree_view_column_new_with_attributes("workspace", cell, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(pager->workspaces_tree), column);
g_signal_connect(cell, "edited", (GCallback) workspace_name_edited, pager);
nr_ws = matewnck_screen_get_workspace_count(pager->screen);
for (i = 0; i < nr_ws; i++)
{
wncklet_connect_while_alive(G_OBJECT(matewnck_screen_get_workspace(pager->screen, i)), "name_changed", G_CALLBACK(workspace_renamed), pager, pager->properties_dialog);
}
update_properties_for_wm(pager);
}
/*
* create target page
*/
void tpage_init()
{
page = gtk_hbox_new(FALSE, 0);
GtkWidget *lbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget *mbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget *rbox = gtk_vbox_new(FALSE, SPACING);
GtkWidget* separator = gtk_vseparator_new();
/* right box with Load/Save buttons */
gtk_container_set_border_width(GTK_CONTAINER(rbox), SPACING);
loadbtn = gtk_button_new_from_stock(GTK_STOCK_OPEN);
g_signal_connect(G_OBJECT(loadbtn), "clicked", G_CALLBACK (on_load_config), (gpointer)TRUE);
savebtn = gtk_button_new_from_stock(GTK_STOCK_SAVE);
g_signal_connect(G_OBJECT(savebtn), "clicked", G_CALLBACK (on_save_config), NULL);
clearbtn = gtk_button_new_from_stock(GTK_STOCK_CLEAR);
g_signal_connect(G_OBJECT(clearbtn), "clicked", G_CALLBACK (on_clear), NULL);
gtk_box_pack_start(GTK_BOX(rbox), loadbtn, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rbox), savebtn, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(rbox), clearbtn, FALSE, TRUE, 0);
GtkWidget *hombox = gtk_hbox_new(TRUE, 0);
/* left box */
gtk_container_set_border_width(GTK_CONTAINER(lbox), SPACING);
/* Target frame */
GtkWidget *frame = gtk_frame_new(_("Target"));
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
/* filename hbox */
GtkWidget *hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
targetname = gtk_entry_new ();
button_browse = gtk_button_new_with_label(_("Browse"));
g_signal_connect(G_OBJECT(button_browse), "clicked", G_CALLBACK (on_target_browse_clicked), NULL);
gtk_box_pack_start(GTK_BOX(hbox), targetname, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), button_browse, FALSE, TRUE, 0);
/* pack in the vertical box */
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* debugger type hbox */
hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
GtkWidget *label = gtk_label_new(_("Debugger:"));
cmb_debugger = gtk_combo_box_new_text();
GList *modules = debug_get_modules();
GList *iter = modules;
while (iter)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(cmb_debugger), (gchar*)iter->data);
iter = iter->next;
}
g_list_free(modules);
gtk_combo_box_set_active(GTK_COMBO_BOX(cmb_debugger), 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), cmb_debugger, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_box_pack_start(GTK_BOX(lbox), frame, FALSE, FALSE, 0);
/* Arguments frame */
frame = gtk_frame_new(_("Arguments"));
hbox = gtk_vbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
textview = gtk_text_view_new ();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(textview), GTK_WRAP_CHAR);
gtk_box_pack_start(GTK_BOX(hbox), textview, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_box_pack_start(GTK_BOX(lbox), frame, TRUE, TRUE, 0);
/* Environment */
gtk_container_set_border_width(GTK_CONTAINER(mbox), SPACING);
frame = gtk_frame_new(_("Environment variables"));
hbox = gtk_hbox_new(FALSE, SPACING);
gtk_container_set_border_width(GTK_CONTAINER(hbox), SPACING);
store = gtk_list_store_new (
N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING);
model = GTK_TREE_MODEL(store);
envtree = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(envtree), TRUE);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW(envtree), GTK_TREE_VIEW_GRID_LINES_VERTICAL);
g_object_set(envtree, "rules-hint", TRUE, NULL);
g_signal_connect(G_OBJECT(envtree), "key-press-event", G_CALLBACK (on_envtree_keypressed), NULL);
gchar *header;
int char_width = get_char_width(envtree);
header = _("Name");
renderer_name = gtk_cell_renderer_text_new ();
g_object_set (renderer_name, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (renderer_name), "edited", G_CALLBACK (on_name_changed), NULL);
column_name = create_column(header, renderer_name, FALSE,
get_header_string_width(header, MW_NAME, char_width),
"text", NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_name);
header = _("Value");
renderer_value = gtk_cell_renderer_text_new ();
column_value = create_column(header, renderer_value, TRUE,
get_header_string_width(header, MW_VALUE, char_width),
"text", VALUE);
g_signal_connect (G_OBJECT (renderer_value), "edited", G_CALLBACK (on_value_changed), NULL);
g_signal_connect (G_OBJECT (renderer_value), "editing-started", G_CALLBACK (on_value_editing_started), NULL);
g_signal_connect (G_OBJECT (renderer_value), "editing-canceled", G_CALLBACK (on_value_editing_cancelled), NULL);
gtk_tree_view_column_set_cell_data_func(column_value, renderer_value, on_render_value, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (envtree), column_value);
/* add empty row */
add_empty_row();
/* set multiple selection */
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(envtree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_box_pack_start(GTK_BOX(hbox), envtree, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(frame), hbox);
gtk_box_pack_start(GTK_BOX(mbox), frame, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hombox), lbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hombox), mbox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), hombox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), separator, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(page), rbox, FALSE, TRUE, 0);
/* update Load/Save config button */
tpage_on_document_activate(document_get_current());
}
static void
gtk_app_chooser_widget_add_items (GtkAppChooserWidget *self)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *sort;
/* create list store */
self->priv->program_list_store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_APP_INFO,
G_TYPE_ICON,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
sort = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (self->priv->program_list_store));
gtk_tree_view_set_model (GTK_TREE_VIEW (self->priv->program_list),
GTK_TREE_MODEL (sort));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
GTK_SORT_ASCENDING);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (sort),
COLUMN_NAME,
gtk_app_chooser_sort_func,
self, NULL);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (self->priv->program_list),
COLUMN_NAME);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (self->priv->program_list),
gtk_app_chooser_search_equal_func,
NULL, NULL);
column = gtk_tree_view_column_new ();
/* initial padding */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
g_object_set (renderer,
"xpad", self->priv->show_all ? 0 : 6,
NULL);
self->priv->padding_renderer = renderer;
/* heading text renderer */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"markup", COLUMN_HEADING_TEXT,
"visible", COLUMN_HEADING,
NULL);
g_object_set (renderer,
"ypad", 6,
"xpad", 0,
"wrap-width", 350,
"wrap-mode", PANGO_WRAP_WORD,
NULL);
/* padding renderer for non-heading cells */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func (column, renderer,
padding_cell_renderer_func,
NULL, NULL);
/* app icon renderer */
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"gicon", COLUMN_GICON,
NULL);
g_object_set (renderer,
"stock-size", GTK_ICON_SIZE_MENU,
NULL);
/* app name renderer */
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"markup", COLUMN_DESC,
NULL);
g_object_set (renderer,
"ellipsize", PANGO_ELLIPSIZE_END,
"ellipsize-set", TRUE,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->program_list), column);
/* populate the widget */
gtk_app_chooser_widget_real_add_items (self);
}
/*****************************************************************************
* Run: Gtk+ thread
*****************************************************************************
* this part of the interface is in a separate thread so that we can call
* gtk_main() from within it without annoying the rest of the program.
*****************************************************************************/
static void Run( intf_thread_t *p_intf )
{
#ifndef NEED_GTK2_MAIN
/* gtk_init needs to know the command line. We don't care, so we
* give it an empty one */
char *p_args[] = { "", NULL };
char **pp_args = p_args;
int i_args = 1;
int i_dummy;
#endif
playlist_t *p_playlist;
GtkCellRenderer *p_renderer = NULL;
GtkTreeViewColumn *p_column = NULL;
GtkListStore *p_filelist = NULL;
GtkListStore *p_playlist_store = NULL;
#ifndef NEED_GTK2_MAIN
gtk_set_locale ();
msg_Dbg( p_intf, "Starting pda GTK2+ interface" );
gtk_init( &i_args, &pp_args );
#else
/* Initialize Gtk+ */
msg_Dbg( p_intf, "Starting pda GTK2+ interface thread" );
gdk_threads_enter();
#endif
/* Create some useful widgets that will certainly be used */
/* FIXME: magic path */
add_pixmap_directory("share");
add_pixmap_directory("/usr/share/vlc");
/* Path for pixmaps under linupy 1.4 */
add_pixmap_directory("/usr/local/share/pixmaps/vlc");
/* Path for pixmaps under linupy 2.0 */
add_pixmap_directory("/usr/share/pixmaps/vlc");
p_intf->p_sys->p_window = create_pda();
if (p_intf->p_sys->p_window == NULL)
{
msg_Err( p_intf, "unable to create pda interface" );
}
/* Store p_intf to keep an eye on it */
gtk_object_set_data( GTK_OBJECT(p_intf->p_sys->p_window),
"p_intf", p_intf );
/* Set the title of the main window */
gtk_window_set_title( GTK_WINDOW(p_intf->p_sys->p_window),
VOUT_TITLE " (PDA Linux interface)");
/* Get the notebook object */
p_intf->p_sys->p_notebook = GTK_NOTEBOOK( gtk_object_get_data(
GTK_OBJECT( p_intf->p_sys->p_window ), "notebook" ) );
/* Get the slider object */
p_intf->p_sys->p_slider = (GtkHScale*) lookup_widget( p_intf->p_sys->p_window, "timeSlider" );
p_intf->p_sys->p_slider_label = (GtkLabel*) lookup_widget( p_intf->p_sys->p_window, "timeLabel" );
if (p_intf->p_sys->p_slider == NULL)
msg_Err( p_intf, "Time slider widget not found." );
if (p_intf->p_sys->p_slider_label == NULL)
msg_Err( p_intf, "Time label widget not found." );
/* Connect the date display to the slider */
p_intf->p_sys->p_adj = gtk_range_get_adjustment( GTK_RANGE(p_intf->p_sys->p_slider) );
if (p_intf->p_sys->p_adj == NULL)
msg_Err( p_intf, "Adjustment range not found." );
g_signal_connect( GTK_OBJECT( p_intf->p_sys->p_adj ), "value_changed",
G_CALLBACK( E_(GtkDisplayDate) ), p_intf );
p_intf->p_sys->f_adj_oldvalue = 0;
p_intf->p_sys->i_adj_oldvalue = 0;
/* BEGIN OF FILEVIEW GTK_TREE_VIEW */
p_intf->p_sys->p_tvfile = NULL;
p_intf->p_sys->p_tvfile = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window,
"tvFileList");
if (NULL == p_intf->p_sys->p_tvfile)
msg_Err(p_intf, "Error obtaining pointer to File List");
/* Insert columns 0 */
p_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 0, (gchar *) N_("Filename"), p_renderer, NULL);
p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 0 );
gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 );
gtk_tree_view_column_set_sort_column_id(p_column, 0);
/* Insert columns 1 */
p_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 1, (gchar *) N_("Permissions"), p_renderer, NULL);
p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 1 );
gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 );
gtk_tree_view_column_set_sort_column_id(p_column, 1);
/* Insert columns 2 */
p_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 2, (gchar *) N_("Size"), p_renderer, NULL);
p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 2 );
gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 );
gtk_tree_view_column_set_sort_column_id(p_column, 2);
/* Insert columns 3 */
p_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 3, (gchar *) N_("Owner"), p_renderer, NULL);
p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 3 );
gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 3 );
gtk_tree_view_column_set_sort_column_id(p_column, 3);
/* Insert columns 4 */
p_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvfile, 4, (gchar *) N_("Group"), p_renderer, NULL);
p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvfile, 4 );
gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 4 );
gtk_tree_view_column_set_sort_column_id(p_column, 4);
/* Get new directory listing */
p_filelist = gtk_list_store_new (5,
G_TYPE_STRING, /* Filename */
G_TYPE_STRING, /* permissions */
G_TYPE_UINT64, /* File size */
G_TYPE_STRING, /* Owner */
G_TYPE_STRING);/* Group */
ReadDirectory(p_intf, p_filelist, ".");
gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile), GTK_TREE_MODEL(p_filelist));
g_object_unref(p_filelist); /* Model will be released by GtkTreeView */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile)),GTK_SELECTION_MULTIPLE);
/* Column properties */
gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvfile, TRUE);
gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvfile);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(p_intf->p_sys->p_tvfile),TRUE);
/* END OF FILEVIEW GTK_TREE_VIEW */
/* BEGIN OF PLAYLIST GTK_TREE_VIEW */
p_intf->p_sys->p_tvplaylist = NULL;
p_intf->p_sys->p_tvplaylist = (GtkTreeView *) lookup_widget( p_intf->p_sys->p_window, "tvPlaylist");
if (NULL == p_intf->p_sys->p_tvplaylist)
msg_Err(p_intf, "Error obtaining pointer to Play List");
/* Columns 1 */
p_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 0, (gchar *) N_("Filename"), p_renderer, NULL);
p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 0 );
gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 0 );
gtk_tree_view_column_set_sort_column_id(p_column, 0);
/* Column 2 */
p_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 1, (gchar *) N_("Time"), p_renderer, NULL);
p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 1 );
gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 1 );
gtk_tree_view_column_set_sort_column_id(p_column, 1);
#if 0
/* Column 3 - is a hidden column used for reliable deleting items from the underlying playlist */
p_renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes(p_intf->p_sys->p_tvplaylist, 2, (gchar *) N_("Index"), p_renderer, NULL);
p_column = gtk_tree_view_get_column(p_intf->p_sys->p_tvplaylist, 2 );
gtk_tree_view_column_add_attribute(p_column, p_renderer, "text", 2 );
gtk_tree_view_column_set_sort_column_id(p_column, 2);
#endif
/* update the playlist */
p_playlist = vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
p_playlist_store = gtk_list_store_new (3,
G_TYPE_STRING, /* Filename */
G_TYPE_STRING, /* Time */
G_TYPE_UINT); /* Hidden index */
PlaylistRebuildListStore(p_playlist_store, p_playlist);
gtk_tree_view_set_model(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist), GTK_TREE_MODEL(p_playlist_store));
g_object_unref(p_playlist_store);
vlc_object_release(p_playlist); /* Free the playlist */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(p_intf->p_sys->p_tvplaylist)),GTK_SELECTION_MULTIPLE);
/* Column properties */
gtk_tree_view_set_headers_visible(p_intf->p_sys->p_tvplaylist, TRUE);
gtk_tree_view_columns_autosize(p_intf->p_sys->p_tvplaylist);
gtk_tree_view_set_headers_clickable(p_intf->p_sys->p_tvplaylist, TRUE);
/* END OF PLAYLIST GTK_TREE_VIEW */
/* Hide the Preference TAB for now. */
GtkWidget *p_preference_tab = NULL;
p_preference_tab = gtk_notebook_get_nth_page(p_intf->p_sys->p_notebook,5);
if (p_preference_tab != NULL)
gtk_widget_hide(p_preference_tab);
/* Show the control window */
gtk_widget_show( p_intf->p_sys->p_window );
#ifdef NEED_GTK2_MAIN
msg_Dbg( p_intf, "Manage GTK keyboard events using threads" );
while( !p_intf->b_die )
{
Manage( p_intf );
/* Sleep to avoid using all CPU - since some interfaces need to
* access keyboard events, a 100ms delay is a good compromise */
gdk_threads_leave();
if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU)
msleep( INTF_IDLE_SLEEP );
else
msleep( 1000 );
gdk_threads_enter();
}
#else
msg_Dbg( p_intf, "Manage GTK keyboard events using timeouts" );
/* Sleep to avoid using all CPU - since some interfaces needs to access
* keyboard events, a 1000ms delay is a good compromise */
if (p_intf->p_libvlc->i_cpu & CPU_CAPABILITY_FPU)
i_dummy = gtk_timeout_add( INTF_IDLE_SLEEP / 1000, (GtkFunction)Manage, p_intf );
else
i_dummy = gtk_timeout_add( 1000, (GtkFunction)Manage, p_intf );
/* Enter Gtk mode */
gtk_main();
/* Remove the timeout */
gtk_timeout_remove( i_dummy );
#endif
gtk_object_destroy( GTK_OBJECT(p_intf->p_sys->p_window) );
#ifdef NEED_GTK2_MAIN
gdk_threads_leave();
#endif
}
static GtkWidget *_create_cluster_combo(void)
{
GtkListStore *model = NULL;
GtkWidget *combo = NULL;
GtkTreeIter iter;
ListIterator itr;
slurmdb_cluster_rec_t *cluster_rec;
GtkCellRenderer *renderer = NULL;
bool got_db = slurm_get_is_association_based_accounting();
int count = 0, spot = 0;
if (!got_db)
return NULL;
cluster_list = slurmdb_get_info_cluster(NULL);
if (!cluster_list || !list_count(cluster_list)) {
FREE_NULL_LIST(cluster_list);
return NULL;
}
if (!orig_cluster_name)
orig_cluster_name = slurm_get_cluster_name();
if (list_count(cluster_list) > 1)
model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_POINTER);
/* Set up the working_cluster_rec just incase we are on a node
that doesn't technically belong to a cluster (like
the node running the slurmdbd).
*/
working_cluster_rec = list_peek(cluster_list);
itr = list_iterator_create(cluster_list);
while ((cluster_rec = list_next(itr))) {
if (model) {
gtk_list_store_append(model, &iter);
gtk_list_store_set(model, &iter,
0, cluster_rec->name,
1, cluster_rec,
-1);
}
if (!xstrcmp(cluster_rec->name, orig_cluster_name)) {
/* clear it since we found the current cluster */
working_cluster_rec = NULL;
spot = count;
}
count++;
}
list_iterator_destroy(itr);
if (model) {
combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
g_object_unref(model);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo),
renderer, true);
gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(combo),
renderer, "text", 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), spot);
g_signal_connect(combo, "changed",
G_CALLBACK(_change_cluster_main),
NULL);
}
return combo;
}
