void
trace_view_load(GtkWidget *view, struct tracecmd_input *handle,
GtkWidget *spin)
{
GtkCellRenderer *renderer;
GtkCellRenderer *fix_renderer;
GtkTreeModel *model;
long c;
/*
* The handle should have loaded the file by now.
* Try to turn off function trace indent and turn on show parent
* if possible.
*/
trace_util_add_option("ftrace:parent", "1");
trace_util_add_option("ftrace:indent", "0");
/* Also, show the function name in the tail for function graph */
trace_util_add_option("fgraph:tailprint", "1");
/* --- CPU column --- */
renderer = gtk_cell_renderer_text_new();
fix_renderer = gtk_cell_renderer_text_new();
g_object_set(fix_renderer,
"family", "Monospace",
"family-set", TRUE,
NULL);
/*
* Set fixed height mode now which will cause all the columns below to
* be created with their sizing property to be set to
* GTK_TREE_VIEW_COLUMN_FIXED.
*/
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(view), TRUE);
for (c = 0; c < NUM_COLS; c++)
{
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view),
-1,
col_labels[c],
(c == COL_LAT || c == COL_INFO) ? fix_renderer : renderer,
trace_view_data_func,
(gpointer)c,
NULL);
}
g_signal_connect_swapped (G_OBJECT (spin), "value-changed",
G_CALLBACK (spin_changed),
(gpointer) view);
if (handle) {
model = create_trace_view_model(handle);
trace_view_store_set_spin_button(TRACE_VIEW_STORE(model), spin);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
g_object_unref(model); /* destroy model automatically with view */
}
}
static void create_treeview(GtkWidget *treeview, GtkWidget *treeview_sw, char *col_names[],
int col_names_count)
{
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_NONE);
/* fixed with and height improve performance */
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW (treeview), FALSE);
gtk_container_add (GTK_CONTAINER (treeview_sw), treeview);
/* add columns to the tree view */
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
/* hack! minimal screen width - scroll bar width - separators and borders */
int width = 430 / col_names_count;
int i;
for (i=0; i<col_names_count; i++) {
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (col_names[i], renderer, "text", i, NULL);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width(col, width);
gtk_tree_view_column_set_clickable(col, FALSE);
gtk_tree_view_column_set_cell_data_func (col, renderer, svinfo_treeview_func_text, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), col);
}
}
static GtkWidget *
editlist_treeview_new (GtkWidget *box, char *title1, char *title2)
{
GtkWidget *scroll;
GtkListStore *store;
GtkTreeViewColumn *col;
GtkWidget *view;
GtkCellRenderer *render;
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
g_signal_connect (G_OBJECT (view), "key_press_event",
G_CALLBACK (editlist_keypress), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (editlist_edited), GINT_TO_POINTER(NAME_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), NAME_COLUMN,
title1, render,
"text", NAME_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (editlist_edited), GINT_TO_POINTER(CMD_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), CMD_COLUMN,
title2, render,
"text", CMD_COLUMN,
NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), NAME_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_column_set_min_width (col, 100);
gtk_container_add (GTK_CONTAINER (scroll), view);
gtk_container_add (GTK_CONTAINER (box), scroll);
gtk_widget_show_all (box);
return view;
}
static void
gwy_graph_data_init(GwyGraphData *graph_data)
{
GtkTreeView *treeview;
if (!quark_id)
quark_id = g_quark_from_static_string("gwy-graph-data-column-id");
graph_data->store = gwy_null_store_new(0);
graph_data->curves = g_array_new(FALSE, FALSE, sizeof(GwyGraphDataCurve));
treeview = GTK_TREE_VIEW(graph_data);
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(graph_data->store));
gtk_tree_view_set_fixed_height_mode(treeview, TRUE);
}
/* Initialize a new TilemDisasmView */
static void tilem_disasm_view_init(TilemDisasmView *dv)
{
GtkTreeView *tv = GTK_TREE_VIEW(dv);
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
dv->use_logical = TRUE;
gtk_tree_view_set_enable_search(tv, FALSE);
gtk_tree_view_set_fixed_height_mode(tv, TRUE);
gtk_tree_view_set_headers_visible(tv, FALSE);
cell = gtk_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new_with_attributes(NULL, cell,
"pixbuf", COL_ICON,
NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(tv, col);
dv->icon_column = col;
cell = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes(_("Addr"), cell,
"text", COL_ADDRESS,
NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(tv, col);
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Disassembly"));
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "xpad", 10, NULL);
gtk_tree_view_column_pack_start(col, cell, FALSE);
gtk_tree_view_column_set_attributes(col, cell,
"text", COL_MNEMONIC,
"visible", COL_SHOW_MNEMONIC,
NULL);
cell = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, cell, TRUE);
gtk_tree_view_column_set_attributes(col, cell,
"text", COL_ARGUMENTS,
NULL);
gtk_tree_view_column_set_sizing(col, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_append_column(tv, col);
}
static void
aim_candidate_init (AimCandidate *candidate)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkListStore *store;
GtkTreeSelection *selection;
gtk_init (0, NULL);
/* gtk tree view */
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING);
candidate->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
g_object_unref (store);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (candidate->treeview));
g_signal_connect (candidate->treeview, "realize",
(GCallback) on_tree_view_realize, candidate);
g_signal_connect (selection, "changed", (GCallback) on_changed, &candidate->iter);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Title", renderer,
"text", TITEL_COLUMN,
NULL);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview), column);
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (candidate->treeview), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (candidate->treeview), FALSE);
/* scrolled window */
GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);
/* gtk window */
candidate->window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_container_set_border_width (GTK_CONTAINER (candidate->window), 1);
gtk_container_add (GTK_CONTAINER (scrolled_window), candidate->treeview);
gtk_container_add (GTK_CONTAINER (candidate->window), scrolled_window);
g_signal_connect (candidate->treeview, "row-activated",
(GCallback) on_tree_view_row_activated, candidate);
}
/* sortcolidx == -1 means 'sortcolidx = colidx' */
static void
append_col (GtkTreeView * treeview, const char *label, int colidx,
int sortcolidx, gint maxwidth)
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END,
NULL);
col = gtk_tree_view_column_new_with_attributes (label, renderer, "text",
colidx, NULL);
g_object_set (G_OBJECT (col), "resizable", TRUE, NULL);
gtk_tree_view_column_set_sort_indicator (col, TRUE);
if (sortcolidx == -1)
sortcolidx = colidx;
gtk_tree_view_column_set_sort_column_id (col, sortcolidx);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_FIXED);
if (maxwidth) {
gtk_tree_view_column_set_fixed_width (col, maxwidth);
gtk_tree_view_column_set_expand (col, FALSE);
} else
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_column_set_cell_data_func (col, renderer,
(GtkTreeCellDataFunc)
treecell_func, NULL, NULL);
gtk_tree_view_append_column (treeview, col);
gtk_tree_view_columns_autosize (treeview);
gtk_tree_view_set_fixed_height_mode (treeview, TRUE);
}
int fileio_load_archive(const char *filename, unsigned char **dataout, int *datasize, int *dataoffset, const char *filetoload, char *outname)
{
FILE *f;
unsigned char idbuf[4];
int filesFound = 0;
std::vector<char *> filelist; // list of files we can load in this archive
// default case: outname is filename
if (outname)
{
strcpy(outname, filename);
}
f = fopen(filename, "rb");
if (!f)
{
return 0; // no good
}
fread(idbuf, 4, 1, f);
fclose(f);
// printf("ID bytes %c %c %x %x\n", idbuf[0], idbuf[1], idbuf[2], idbuf[3]);
// Handle all archives with common libarchive code
if ((idbuf[0] == 'P') && (idbuf[1] == 'K') && (idbuf[2] == 0x03) && (idbuf[3] == 0x04) || // zip
((idbuf[0] == '7') && (idbuf[1] == 'z') && (idbuf[2] == 0xbc) && (idbuf[3] == 0xaf)) || // 7zip
((idbuf[0] == 0xfd) && (idbuf[1] == 0x37) && (idbuf[2] == 0x7a) && (idbuf[3] == 0x58)) || // txz
((idbuf[0] == 0x1f) && (idbuf[1] == 0x8b) && (idbuf[2] == 0x08) && (idbuf[3] == 0x00)) || // tgz
((idbuf[0] == 0x42) && (idbuf[1] == 0x5a) && (idbuf[2] == 0x68) && (idbuf[3] == 0x39)) // tbz
) {
a = archive_read_new();
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
r = archive_read_open_filename(a, filename, 10240);
int64_t entry_size;
if (r != ARCHIVE_OK) {
print_message("Archive failed to open.");
}
while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
const char *currentFile = archive_entry_pathname(entry);
unsigned char *fileContents;
entry_size = archive_entry_size(entry);
fileContents = (unsigned char *)malloc(entry_size);
if (filetoload != NULL) {
if (!strcmp(currentFile, filetoload)) {
archive_read_data(a, fileContents, entry_size);
archive_read_data_skip(a);
r = archive_read_free(a);
*datasize = entry_size;
*dataout = fileContents;
*dataoffset = 0;
return 1;
}
}
else {
if (checkExtension(currentFile))
{
char *tmpstr;
tmpstr = (char *)malloc(strlen(currentFile)+1);
strcpy(tmpstr, currentFile);
// add to the file list
filelist.push_back(tmpstr);
filesFound++;
}
}
}
}
else if ((idbuf[0] == 'R') && (idbuf[1] == 'a') && (idbuf[2] == 'r') && (idbuf[3] == '!'))
{ // it's rar
print_message("Rar files are not supported.");
}
// if we found any files and weren't forced to load them, handle accordingly
if (filesFound)
{
// only 1 file found, just run it
if (filesFound == 1)
{
char fname[512];
strcpy(fname, filelist[0]);
free(filelist[0]);
filelist.clear();
strcpy(outname, fname);
return fileio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
else // multiple files we can handle found, give the user a choice
{
int sel;
char fname[512];
GtkWidget *archselect = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (archselect), "Pick game in archive");
gtk_window_set_modal(GTK_WINDOW (archselect), TRUE);
GtkWidget *archbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(archselect), archbox);
gtk_widget_show(archbox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(archbox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 340, 340);
gtk_widget_show(scrolledwindow);
GtkWidget *buttonbox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(archbox), buttonbox, FALSE, TRUE, 0);
gtk_widget_show(buttonbox);
GtkWidget *archtree = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER (scrolledwindow), archtree);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (archtree), FALSE);
g_signal_connect(G_OBJECT(archtree), "button_press_event", G_CALLBACK(check_list_double), NULL);
gtk_widget_show(archtree);
// set up our tree store
treestore = gtk_tree_store_new(1, G_TYPE_STRING);
// attach the store to the tree
gtk_tree_view_set_model(GTK_TREE_VIEW(archtree), GTK_TREE_MODEL(treestore));
for (int fn = 0; fn < filelist.size(); fn++)
{
gtk_tree_store_insert(treestore, &treeiters[fn], NULL, 999999);
gtk_tree_store_set(treestore, &treeiters[fn], 0, filelist[fn], -1);
}
// create a cell renderer using the stock text one
renderer = gtk_cell_renderer_text_new();
// create a display column using the renderer
column = gtk_tree_view_column_new_with_attributes ("NES file",
renderer,
"text", 0,
NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column(GTK_TREE_VIEW (archtree), column);
GtkWidget *archcancel = gtk_widget_new(GTK_TYPE_BUTTON, "label", GTK_STOCK_CANCEL, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL);
gtk_button_set_use_stock(GTK_BUTTON(archcancel), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), archcancel, FALSE, FALSE, 0);
gtk_widget_show(archcancel);
GtkWidget *archok = gtk_widget_new(GTK_TYPE_BUTTON, "label", GTK_STOCK_OK, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL);
gtk_button_set_use_stock(GTK_BUTTON(archok), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), archok, FALSE, FALSE, 0);
gtk_widget_show(archok);
// get the selection object too
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(archtree));
g_signal_connect(G_OBJECT(archcancel), "clicked",
G_CALLBACK(on_archcancel_clicked), NULL);
g_signal_connect(G_OBJECT(archok), "clicked",
G_CALLBACK(on_archok_clicked), NULL);
g_signal_connect(G_OBJECT(archselect), "destroy",
G_CALLBACK(on_archselect_destroyed), NULL);
gtk_widget_show(archselect);
run_picker = true;
cancelled = false;
while (run_picker)
{
gtk_main_iteration_do(TRUE);
}
sel = find_current_selection();
gtk_widget_destroy(archselect);
// was something picked?
if ((sel != -1) && (!cancelled))
{
strcpy(fname, filelist[sel]);
}
// free all the temp filenames
for (int fn = 0; fn < filelist.size(); fn++)
{
free(filelist[fn]);
}
// and wipe the vector
filelist.clear();
if ((sel != -1) && (!cancelled))
{
if (outname)
{
strcpy(outname, fname);
}
return fileio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
}
}
return 0;
}
static GtkWidget *
key_dialog_treeview_new (GtkWidget *box)
{
GtkWidget *scroll;
GtkListStore *store, *combostore;
GtkTreeViewColumn *col;
GtkWidget *view;
GtkCellRenderer *render;
int i;
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
g_return_val_if_fail (store != NULL, NULL);
view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (view), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (view), FALSE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (view), TRUE);
g_signal_connect (G_OBJECT (view), "key-press-event",
G_CALLBACK (key_dialog_keypress), NULL);
g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW(view))),
"changed", G_CALLBACK (key_dialog_selection_changed), NULL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
render = gtk_cell_renderer_accel_new ();
g_object_set (render, "editable", TRUE,
#ifndef WIN32
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_OTHER,
#endif
NULL);
g_signal_connect (G_OBJECT (render), "accel-edited",
G_CALLBACK (key_dialog_set_key), NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), KEY_COLUMN,
"Key", render,
"text", KEY_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), ACCEL_COLUMN,
"Accel", render,
"text", ACCEL_COLUMN,
NULL);
combostore = gtk_list_store_new (1, G_TYPE_STRING);
for (i = 0; i <= KEY_MAX_ACTIONS; i++)
{
GtkTreeIter iter;
if (key_actions[i].name[0])
{
gtk_list_store_append (combostore, &iter);
gtk_list_store_set (combostore, &iter, 0, key_actions[i].name, -1);
}
}
render = gtk_cell_renderer_combo_new ();
g_object_set (G_OBJECT (render), "model", combostore,
"has-entry", FALSE,
"editable", TRUE,
"text-column", 0,
NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (ACTION_COLUMN));
g_signal_connect (G_OBJECT (render), "changed",
G_CALLBACK (key_dialog_combo_changed), combostore);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (view), ACTION_COLUMN,
"Action", render,
"text", ACTION_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D1_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), D1_COLUMN,
"Data1", render,
"text", D1_COLUMN,
NULL);
render = gtk_cell_renderer_text_new ();
g_object_set (render, "editable", TRUE, NULL);
g_signal_connect (G_OBJECT (render), "edited",
G_CALLBACK (key_dialog_entry_edited), GINT_TO_POINTER (D2_COLUMN));
gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (view), D2_COLUMN,
"Data2", render,
"text", D2_COLUMN,
NULL);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), KEY_COLUMN);
gtk_tree_view_column_set_fixed_width (col, 200);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACCEL_COLUMN);
gtk_tree_view_column_set_visible (col, FALSE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), ACTION_COLUMN);
gtk_tree_view_column_set_fixed_width (col, 160);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D1_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_min_width (col, 80);
gtk_tree_view_column_set_resizable (col, TRUE);
col = gtk_tree_view_get_column (GTK_TREE_VIEW (view), D2_COLUMN);
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_min_width (col, 80);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_container_add (GTK_CONTAINER (scroll), view);
gtk_container_add (GTK_CONTAINER (box), scroll);
return view;
}
GtkWidget *gtkui_cheats() {
// Create the Cheats window
if (cheatwindow) { return NULL; }
cheatwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (cheatwindow), "Cheat Manager");
GtkWidget *cheatbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(cheatwindow), cheatbox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 512, 256);
treeview = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER (scrolledwindow), treeview);
infobar = gtk_info_bar_new();
infolabel = gtk_widget_new(GTK_TYPE_LABEL,"label", "", NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), infobar, TRUE, TRUE, 0);
GtkWidget *content_area = gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar));
gtk_box_pack_start(GTK_BOX(content_area), infolabel, TRUE, TRUE, 0);
GtkWidget *opensavebox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), opensavebox, FALSE, FALSE, 0);
GtkWidget *cheatopen = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Open",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatopen, FALSE, FALSE, 0);
GtkWidget *cheatclear = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Clear",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatclear, FALSE, FALSE, 0);
GtkWidget *cheatremove = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Remove",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(opensavebox), cheatremove, FALSE, FALSE, 0);
GtkWidget *descbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), descbox, FALSE, FALSE, 0);
GtkWidget *desclabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Description:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), desclabel, FALSE, FALSE, 0);
descedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(descbox), descedit, TRUE, TRUE, 0);
GtkWidget *ggbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), ggbox, FALSE, FALSE, 0);
GtkWidget *gglabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Game Genie:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), gglabel, FALSE, FALSE, 0);
ggedit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), ggedit, TRUE, TRUE, 0);
GtkWidget *genieadd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Add",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(ggbox), genieadd, FALSE, FALSE, 0);
GtkWidget *parbox = gtk_widget_new(
GTK_TYPE_BOX,
"halign", GTK_ALIGN_END,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), parbox, FALSE, FALSE, 0);
GtkWidget *parlabel = gtk_widget_new(
GTK_TYPE_LABEL,
"label", "Pro Action Rocky:",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-left", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), parlabel, FALSE, FALSE, 0);
paredit = gtk_widget_new(
GTK_TYPE_ENTRY,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), paredit, FALSE, FALSE, 0);
GtkWidget *paradd = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "Add",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(parbox), paradd, FALSE, FALSE, 0);
GtkWidget *cheatok = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", "OK",
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_box_pack_start(GTK_BOX(cheatbox), cheatok, FALSE, FALSE, 0);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(treeview), FALSE);
treestore = gtk_tree_store_new(5, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
GtkCellRenderer *checkbox = gtk_cell_renderer_toggle_new();
GtkTreeViewColumn *column[5];
// create the display columns
column[0] = gtk_tree_view_column_new_with_attributes("Enable", checkbox, "active", 0, NULL);
column[1] = gtk_tree_view_column_new_with_attributes("Game Genie", renderer, "text", 1, NULL);
column[2] = gtk_tree_view_column_new_with_attributes("PAR", renderer, "text", 2, NULL);
column[3] = gtk_tree_view_column_new_with_attributes("Raw", renderer, "text", 3, NULL);
column[4] = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", 4, NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[0]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[1]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[2]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[3]);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column[4]);
gtkui_cheats_fill_tree(nstpaths.cheatpath);
/*g_signal_connect(G_OBJECT(checkbox), "toggled",
G_CALLBACK(gtkui_cheats_check), NULL);*/
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(gtkui_cheats_toggle), NULL);
g_signal_connect(G_OBJECT(cheatopen), "clicked",
G_CALLBACK(gtkui_cheats_load), NULL);
g_signal_connect(G_OBJECT(cheatclear), "clicked",
G_CALLBACK(gtkui_cheats_clear), NULL);
g_signal_connect(G_OBJECT(cheatremove), "clicked",
G_CALLBACK(gtkui_cheats_remove), NULL);
g_signal_connect(G_OBJECT(genieadd), "clicked",
G_CALLBACK(gtkui_cheats_gg_add), NULL);
g_signal_connect(G_OBJECT(paradd), "clicked",
G_CALLBACK(gtkui_cheats_par_add), NULL);
g_signal_connect(G_OBJECT(cheatok), "clicked",
G_CALLBACK(gtkui_cheats_ok), NULL);
g_signal_connect(G_OBJECT(cheatwindow), "destroy",
G_CALLBACK(gtkui_cheats_ok), NULL);
gtk_widget_show_all(cheatwindow);
gtk_widget_hide(infobar);
return cheatwindow;
}
static void
tabu_playlist_init (TabuPlaylist *self)
{
gtk_scrolled_window_set_shadow_type (
GTK_SCROLLED_WINDOW (self),
GTK_SHADOW_IN);
gtk_scrolled_window_set_hadjustment (
GTK_SCROLLED_WINDOW (self),
NULL);
gtk_scrolled_window_set_vadjustment (
GTK_SCROLLED_WINDOW (self),
NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (self),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
self->tree_view = gtk_tree_view_new ( );
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (self->tree_view), TRUE);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (self->tree_view), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (self->tree_view), TRUE);
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (self->tree_view), TRUE);
gtk_tree_selection_set_mode (
GTK_TREE_SELECTION (
gtk_tree_view_get_selection (GTK_TREE_VIEW (self->tree_view))),
GTK_SELECTION_MULTIPLE);
self->cell_renderer = gtk_cell_renderer_text_new ();
g_object_set (self->cell_renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
GtkTreeViewColumn *pointercol = gtk_tree_view_column_new_with_attributes(
"Pointer",
GTK_CELL_RENDERER (self->cell_renderer),
"markup", 0,
NULL );
self->tree_view_column = gtk_tree_view_column_new_with_attributes(
"Cancion",
GTK_CELL_RENDERER (self->cell_renderer),
"markup", 1,
NULL );
gtk_tree_view_column_set_sizing (self->tree_view_column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_sizing (pointercol, GTK_TREE_VIEW_COLUMN_FIXED);
// gtk_tree_view_column_set_fixed_width (pointercol, 15 );;
gtk_tree_view_column_set_expand (GTK_TREE_VIEW_COLUMN (self->tree_view_column), TRUE);
gtk_tree_view_insert_column (
GTK_TREE_VIEW (self->tree_view),
pointercol,
-1);
gtk_tree_view_insert_column (
GTK_TREE_VIEW (self->tree_view),
self->tree_view_column,
-1);
self->list_store = gtk_list_store_new (
3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
gtk_tree_view_set_model (
GTK_TREE_VIEW (self->tree_view),
GTK_TREE_MODEL (self->list_store));
g_signal_connect (
G_OBJECT (self->tree_view),
"row-activated",
G_CALLBACK (on_tabu_playlist_row_activated_event),
NULL);
g_signal_connect (
G_OBJECT (self->tree_view),
"key-press-event",
G_CALLBACK (on_tabu_playlist_key_press_event),
NULL);
gtk_container_add (
GTK_CONTAINER ( GTK_SCROLLED_WINDOW (self)),
GTK_WIDGET (self->tree_view));
}
int auxio_load_archive(const char *filename, unsigned char **dataout, int *datasize, int *dataoffset, const char *filetoload, char *outname)
{
FILE *f;
unsigned char idbuf[4];
int filesFound = 0;
std::vector<char *> filelist; // list of files we can load in this archive
// default case: outname is filename
if (outname)
{
strcpy(outname, filename);
}
f = fopen(filename, "rb");
if (!f)
{
return 0; // no good
}
fread(idbuf, 4, 1, f);
fclose(f);
// printf("ID bytes %c %c %x %x\n", idbuf[0], idbuf[1], idbuf[2], idbuf[3]);
if ((idbuf[0] == 'P') && (idbuf[1] == 'K') && (idbuf[2] == 0x03) && (idbuf[3] == 0x04))
{ // it's zip
unzFile zipArchive;
char file_name[1024];
unz_file_info info;
int nlen;
int ret = 0;
zipArchive = unzOpen(filename);
if (!zipArchive)
{
return 0;
}
unzGoToFirstFile(zipArchive);
for (;;)
{
if (unzGetCurrentFileInfo(zipArchive, &info, file_name, 1024, NULL, 0, NULL, 0) == UNZ_OK)
{
if (filetoload != NULL)
{
if (!strcasecmp(filetoload, file_name))
{
int length;
unsigned char *buffer;
unzOpenCurrentFile(zipArchive);
length = info.uncompressed_size;
buffer = (unsigned char *)malloc(length);
ret = unzReadCurrentFile(zipArchive, buffer, length);
if (ret != length)
{
free(buffer);
return 0;
}
unzCloseCurrentFile(zipArchive);
unzClose(zipArchive);
*datasize = length;
*dataout = buffer;
*dataoffset = 0;
return 1;
}
}
else
{
if (checkExtension(file_name))
{
char *tmpstr;
tmpstr = (char *)malloc(strlen(file_name)+1);
strcpy(tmpstr, file_name);
// add to the file list
filelist.push_back(tmpstr);
filesFound++;
}
}
}
else
{
break;
}
ret = unzGoToNextFile(zipArchive);
if (ret == UNZ_END_OF_LIST_OF_FILE)
{
break;
}
if (ret != UNZ_OK)
{
unzClose(zipArchive);
return 0;
}
}
unzClose(zipArchive);
}
else if ((idbuf[0] == '7') && (idbuf[1] == 'z') && (idbuf[2] == 0xbc) && (idbuf[3] == 0xaf))
{ // it's 7zip
CFileInStream archiveStream;
SRes res;
CSzArEx db; /* 7z archive database structure */
ISzAlloc allocImp; /* memory functions for main pool */
ISzAlloc allocTempImp; /* memory functions for temporary pool */
archiveStream.File = fopen(filename, "rb");
if (!archiveStream.File)
{
return 0;
}
archiveStream.InStream.Read = SzFileReadImp;
archiveStream.InStream.Seek = SzFileSeekImp;
allocImp.Alloc = SzAlloc;
allocImp.Free = SzFree;
allocTempImp.Alloc = SzAllocTemp;
allocTempImp.Free = SzFreeTemp;
// init 7zip internals
CrcGenerateTable();
SzArEx_Init(&db);
res = SzArEx_Open(&db, &archiveStream.InStream, &allocImp, &allocTempImp);
if (res == SZ_OK)
{
int i;
for (i = 0; i < db.db.NumFiles; i++)
{
CSzFileItem *item = db.db.Files + i;
if (!item->IsDirectory)
{
if (filetoload != NULL)
{
if (!strcasecmp(filetoload, item->Name))
{
UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
size_t offset;
size_t outSizeProcessed;
res = SzAr_Extract(&db, &archiveStream.InStream, i,
&blockIndex, &outBuffer, &outBufferSize,
&offset, &outSizeProcessed,
&allocImp, &allocTempImp);
if (res == SZ_OK)
{
SzArEx_Free(&db, &allocImp);
fclose(archiveStream.File);
*datasize = (int)outBufferSize;
*dataout = (unsigned char *)outBuffer;
*dataoffset = (int)offset;
return 1;
}
else
{
std::cout << "Error extracting 7zip!\n";
}
}
}
if (checkExtension(item->Name))
{
char *tmpstr;
tmpstr = (char *)malloc(strlen(item->Name)+1);
strcpy(tmpstr, item->Name);
// add to the file list
filelist.push_back(tmpstr);
filesFound++;
}
}
}
SzArEx_Free(&db, &allocImp);
fclose(archiveStream.File);
}
}
else if ((idbuf[0] == 'R') && (idbuf[1] == 'a') && (idbuf[2] == 'r') && (idbuf[3] == '!'))
{ // it's rar
}
// if we found any files and weren't forced to load them, handle accordingly
if (filesFound)
{
// only 1 file found, just run it
if (filesFound == 1)
{
char fname[512];
strcpy(fname, filelist[0]);
free(filelist[0]);
filelist.clear();
strcpy(outname, fname);
return auxio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
else // multiple files we can handle found, give the user a choice
{
int sel;
char fname[512];
filepicker = create_archselect();
tree = lookup_widget(filepicker, "archtree");
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (tree), FALSE);
g_signal_connect(G_OBJECT(tree), "button_press_event", G_CALLBACK(check_list_double), NULL);
// set up our tree store
treestore = gtk_tree_store_new(1, G_TYPE_STRING);
// attach the store to the tree
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(treestore));
// create a cell renderer using the stock text one
renderer = gtk_cell_renderer_text_new();
// create a display column using the renderer
column = gtk_tree_view_column_new_with_attributes ("NES file",
renderer,
"text", 0,
NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
// get the selection object too
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
// add the filenames
for (int fn = 0; fn < filelist.size(); fn++)
{
gtk_tree_store_insert(treestore, &treeiters[fn], NULL, 999999);
gtk_tree_store_set(treestore, &treeiters[fn], 0, filelist[fn], -1);
}
gtk_widget_show(filepicker);
run_picker = true;
cancelled = false;
while (run_picker)
{
gtk_main_iteration_do(FALSE);
}
sel = find_current_selection();
gtk_widget_destroy(filepicker);
// was something picked?
if ((sel != -1) && (!cancelled))
{
strcpy(fname, filelist[sel]);
}
// free all the temp filenames
for (int fn = 0; fn < filelist.size(); fn++)
{
free(filelist[fn]);
}
// and wipe the vector
filelist.clear();
if ((sel != -1) && (!cancelled))
{
if (outname)
{
strcpy(outname, fname);
}
return auxio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
}
}
return 0;
}
/* Create list */
static GtkWidget *
create_list(void)
{
GtkListStore *list_store;
GtkWidget *list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSortable *sortable;
GtkTreeView *list_view;
GtkTreeSelection *selection;
/* Create the store */
list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/
G_TYPE_STRING, /* SI */
G_TYPE_INT, /* Num MSUs */
G_TYPE_STRING, /* MSUs/sec */
G_TYPE_INT, /* Num Bytes */
G_TYPE_STRING, /* Bytes/MSU */
G_TYPE_STRING); /* Bytes/sec */
/* Create a view */
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
list_view = GTK_TREE_VIEW(list);
sortable = GTK_TREE_SORTABLE(list_store);
/* Speed up the list display */
gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
/* Setup the sortable columns */
gtk_tree_sortable_set_sort_column_id(sortable, SI_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_view_set_headers_clickable(list_view, FALSE);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
/* 1:st column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("SI", renderer,
"text", SI_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, SI_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 110);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
/* 2:nd column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num MSUs", renderer,
"text", NUM_MSUS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 3:d column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("MSUs/sec", renderer,
"text", NUM_MSUS_SEC_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_SEC_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 4:d column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
"text", NUM_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 5:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Bytes/MSU", renderer,
"text", NUM_BYTES_MSU_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_MSU_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 6:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Bytes/sec", renderer,
"text", NUM_BYTES_SEC_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_SEC_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* Now enable the sorting of each column */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
return list;
}
GtkWidget*
listview__new()
{
//the main pane. A treeview with a list of samples.
LibraryView* lv = app->libraryview = g_new0(LibraryView, 1);
lv->scroll = scrolled_window_new();
GtkWidget* view = app->libraryview->widget = gtk_tree_view_new_with_model(GTK_TREE_MODEL(samplecat.store));
gtk_container_add(GTK_CONTAINER(lv->scroll), view);
g_signal_connect(view, "realize", G_CALLBACK(listview__on_realise), NULL);
g_signal_connect(view, "motion-notify-event", (GCallback)listview__on_motion, NULL);
g_signal_connect(view, "drag-data-received", G_CALLBACK(listview__drag_received), NULL); //currently the window traps this before we get here.
g_signal_connect(view, "drag-motion", G_CALLBACK(drag_motion), NULL);
#if 0 // TODO why does this not work?
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(view), TRUE);
#endif
//set up as dnd source:
gtk_drag_source_set(view, GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
dnd_file_drag_types, dnd_file_drag_types_count,
GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_ASK);
g_signal_connect(G_OBJECT(view), "drag_data_get", G_CALLBACK(listview__dnd_get), NULL);
//icon:
GtkCellRenderer* cell9 = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn* col9 /*= app->col_icon*/ = gtk_tree_view_column_new_with_attributes("", cell9, "pixbuf", COL_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col9);
//g_object_set(cell4, "cell-background", "Orange", "cell-background-set", TRUE, NULL);
g_object_set(G_OBJECT(cell9), "xalign", 0.0, NULL);
gtk_tree_view_column_set_resizable(col9, TRUE);
gtk_tree_view_column_set_min_width(col9, 0);
gtk_tree_view_column_set_cell_data_func(col9, cell9, listview__cell_data_bg, NULL, NULL);
#ifdef SHOW_INDEX
GtkCellRenderer* cell0 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col0 = gtk_tree_view_column_new_with_attributes("Id", cell0, "text", COL_IDX, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col0);
#endif
GtkCellRenderer* cell1 = lv->cells.name = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col1 = lv->col_name = gtk_tree_view_column_new_with_attributes("Sample Name", cell1, "text", COL_NAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col1);
gtk_tree_view_column_set_sort_column_id(col1, COL_NAME);
gtk_tree_view_column_set_reorderable(col1, TRUE);
gtk_tree_view_column_set_min_width(col1, 0);
//gtk_tree_view_column_set_spacing(col1, 10);
//g_object_set(cell1, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col1, cell1, (gpointer)listview__cell_data_bg, NULL, NULL);
//gtk_tree_view_column_set_cell_data_func(col1, cell1, (gpointer)cell_bg_lighter, NULL, NULL);
gtk_tree_view_column_set_sizing(col1, GTK_TREE_VIEW_COLUMN_FIXED);
int width = atoi(app->config.column_widths[0]);
if(width > 0) gtk_tree_view_column_set_fixed_width(col1, MAX(width, 30)); //FIXME set range in config section instead.
else gtk_tree_view_column_set_fixed_width(col1, 130);
GtkCellRenderer* cell2 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col2 = lv->col_path = gtk_tree_view_column_new_with_attributes("Path", cell2, "text", COL_FNAME, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col2);
gtk_tree_view_column_set_sort_column_id(col2, COL_FNAME);
//gtk_tree_view_column_set_resizable(col2, FALSE);
gtk_tree_view_column_set_reorderable(col2, TRUE);
gtk_tree_view_column_set_min_width(col2, 0);
//g_object_set(cell2, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col2, cell2, listview__path_cell_data, NULL, NULL);
#ifdef USE_AYYI
//icon that shows when file is in current active song.
GtkCellRenderer* ayyi_renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(col2, ayyi_renderer, FALSE);
gtk_tree_view_column_add_attribute(col2, ayyi_renderer, "pixbuf", COL_AYYI_ICON);
//gtk_tree_view_column_set_cell_data_func(col2, ayyi_renderer, vdtree_color_cb, vdt, NULL);
#endif
gtk_tree_view_column_set_sizing(col2, GTK_TREE_VIEW_COLUMN_FIXED);
width = atoi(app->config.column_widths[1]);
if(width > 0) gtk_tree_view_column_set_fixed_width(col2, MAX(width, 30));
else gtk_tree_view_column_set_fixed_width(col2, 130);
//GtkCellRenderer *cell3 /*= app->cell_tags*/ = gtk_cell_renderer_text_new();
GtkCellRenderer* cell3 = lv->cells.tags = gtk_cell_renderer_hyper_text_new();
GtkTreeViewColumn* column3 = lv->col_tags = gtk_tree_view_column_new_with_attributes("Tags", cell3, "text", COL_KEYWORDS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column3);
gtk_tree_view_column_set_sort_column_id(column3, COL_KEYWORDS);
gtk_tree_view_column_set_resizable(column3, TRUE);
gtk_tree_view_column_set_reorderable(column3, TRUE);
gtk_tree_view_column_set_min_width(column3, 0);
g_object_set(cell3, "editable", TRUE, NULL);
g_signal_connect(cell3, "edited", (GCallback)listview__on_keywords_edited, NULL);
gtk_tree_view_column_add_attribute(column3, cell3, "markup", COL_KEYWORDS);
gtk_tree_view_column_set_cell_data_func(column3, cell3, listview__tag_cell_data, NULL, NULL);
GtkCellRenderer* cell4 = gtk_cell_renderer_pixbuf_new();
GtkTreeViewColumn* col4 = lv->col_pixbuf = gtk_tree_view_column_new_with_attributes("Overview", cell4, "pixbuf", COL_OVERVIEW, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col4);
//g_object_set(cell4, "cell-background", "Orange", "cell-background-set", TRUE, NULL);
g_object_set(G_OBJECT(cell4), "xalign", 0.0, NULL);
gtk_tree_view_column_set_resizable(col4, TRUE);
gtk_tree_view_column_set_min_width(col4, 0);
//g_object_set(cell4, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col4, cell4, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell5 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col5 = gtk_tree_view_column_new_with_attributes("Length", cell5, "text", COL_LENGTH, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col5);
gtk_tree_view_column_set_sort_column_id(col5, COL_LEN);
gtk_tree_view_column_set_resizable(col5, TRUE);
gtk_tree_view_column_set_reorderable(col5, TRUE);
gtk_tree_view_column_set_min_width(col5, 0);
g_object_set(G_OBJECT(cell5), "xalign", 1.0, NULL);
//g_object_set(cell5, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col5, cell5, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell6 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col6 = gtk_tree_view_column_new_with_attributes("Srate", cell6, "text", COL_SAMPLERATE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col6);
gtk_tree_view_column_set_resizable(col6, TRUE);
gtk_tree_view_column_set_reorderable(col6, TRUE);
gtk_tree_view_column_set_min_width(col6, 0);
g_object_set(G_OBJECT(cell6), "xalign", 1.0, NULL);
//g_object_set(cell6, "ypad", 0, NULL);
gtk_tree_view_column_set_cell_data_func(col6, cell6, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell7 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col7 = gtk_tree_view_column_new_with_attributes("Chs", cell7, "text", COL_CHANNELS, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col7);
gtk_tree_view_column_set_resizable(col7, TRUE);
gtk_tree_view_column_set_reorderable(col7, TRUE);
gtk_tree_view_column_set_min_width(col7, 0);
g_object_set(G_OBJECT(cell7), "xalign", 1.0, NULL);
gtk_tree_view_column_set_cell_data_func(col7, cell7, listview__cell_data_bg, NULL, NULL);
GtkCellRenderer* cell8 = gtk_cell_renderer_text_new();
GtkTreeViewColumn* col8 = gtk_tree_view_column_new_with_attributes("Mimetype", cell8, "text", COL_MIMETYPE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col8);
gtk_tree_view_column_set_resizable(col8, TRUE);
gtk_tree_view_column_set_reorderable(col8, TRUE);
gtk_tree_view_column_set_min_width(col8, 0);
//g_object_set(G_OBJECT(cell8), "xalign", 1.0, NULL);
gtk_tree_view_column_set_cell_data_func(col8, cell8, listview__cell_data_bg, NULL, NULL);
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(view), COL_NAME);
g_signal_connect((gpointer)view, "button-press-event", G_CALLBACK(listview__on_row_clicked), NULL);
g_signal_connect((gpointer)view, "cursor-changed", G_CALLBACK(listview__on_cursor_change), NULL);
g_signal_connect(G_OBJECT(samplecat.store), "content-changed", G_CALLBACK(listview__on_store_changed), NULL);
#if 0
void on_unrealize(GtkWidget* widget, gpointer user_data)
{
PF0;
}
g_signal_connect((gpointer)view, "unrealize", G_CALLBACK(on_unrealize), NULL);
#endif
void listview_on_play(GObject* _app, gpointer _)
{
if(app->play.sample->row_ref){
listview__highlight_playing_by_ref(app->play.sample->row_ref);
}
}
g_signal_connect(app, "play-start", (GCallback)listview_on_play, NULL);
void on_sort_order_changed(GtkTreeSortable* sortable, gpointer user_data)
{
gint sort_column_id;
GtkSortType order;
if(gtk_tree_sortable_get_sort_column_id(sortable, &sort_column_id, &order)){
if(sort_column_id == COL_LEN){
int n_rows = ((SamplecatListStore*)samplecat.store)->row_count;
if(n_rows >= LIST_STORE_MAX_ROWS){
dbg(0, "TODO need to requery database ordered by length...");
}
}
}
}
gint gui_history_sms(void)
{
SphoneStoreTreeModel *calls;
static GtkWidget *calls_view=NULL;
debug("gui_history_sms\n");
if(sms_window){
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_ALL, NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_window_present(GTK_WINDOW(sms_window));
return 0;
}
sms_window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(sms_window),"SMS History");
gtk_window_set_default_size(GTK_WINDOW(sms_window),600,220);
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *scroll;
calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("", renderer, "pixbuf", SPHONE_STORE_TREE_MODEL_COLUMN_PICTURE, NULL);
gtk_tree_view_column_set_fixed_width(column,40);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Name", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_NAME, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
GtkWidget *sms_content=gtk_label_new (NULL);
gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE);
g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content);
g_signal_connect_after(G_OBJECT(calls_view),"row-activated", G_CALLBACK(gui_contact_book_double_click_callback),NULL);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
gtk_container_add (GTK_CONTAINER(v1),scroll);
gtk_container_add (GTK_CONTAINER(v1),sms_content);
gtk_container_add (GTK_CONTAINER(sms_window),v1);
g_signal_connect(G_OBJECT(sms_window),"delete-event", G_CALLBACK(gui_contact_make_null),&sms_window);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_ALL, NULL);
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_widget_show_all(sms_window);
return 0;
}
static void
rb_grilo_source_constructed (GObject *object)
{
RBGriloSource *source;
RBShell *shell;
RBShellPlayer *shell_player;
const GList *source_keys;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkWidget *scrolled;
GtkWidget *browserbox;
GtkWidget *vbox;
GtkWidget *mainbox;
GtkAdjustment *adjustment;
RB_CHAIN_GOBJECT_METHOD (rb_grilo_source_parent_class, constructed, object);
source = RB_GRILO_SOURCE (object);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell,
"db", &source->priv->db,
"shell-player", &shell_player,
NULL);
g_object_unref (shell);
g_object_get (source, "entry-type", &source->priv->entry_type, NULL);
source->priv->entry_view = rb_entry_view_new (source->priv->db, G_OBJECT (shell_player), TRUE, FALSE);
g_object_unref (shell_player);
g_signal_connect (source->priv->entry_view,
"notify::sort-order",
G_CALLBACK (notify_sort_order_cb),
source);
source_keys = grl_source_supported_keys (source->priv->grilo_source);
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST));
}
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM));
}
/*
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DATE));
}
*/
if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION))) {
rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE);
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys,
GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION));
}
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_CHILDCOUNT));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_URL));
source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_THUMBNAIL));
/* probably add an image column too? */
source->priv->browser_model = gtk_tree_store_new (4, GRL_TYPE_MEDIA, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT);
source->priv->browser_view = gtk_tree_view_new ();
gtk_tree_view_set_model (GTK_TREE_VIEW (source->priv->browser_view), GTK_TREE_MODEL (source->priv->browser_model));
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_set_title (column, _("Browse"));
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_add_attribute (column, renderer, "text", 1);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_expander_column (GTK_TREE_VIEW (source->priv->browser_view), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (source->priv->browser_view), TRUE);
g_signal_connect (source->priv->browser_view, "row-expanded", G_CALLBACK (browser_row_expanded_cb), source);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* should be multiple eventually */
g_signal_connect (selection, "changed", G_CALLBACK (browser_selection_changed_cb), source);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled));
g_signal_connect (adjustment, "changed", G_CALLBACK (scroll_adjust_changed_cb), source);
g_signal_connect (adjustment, "value-changed", G_CALLBACK (scroll_adjust_value_changed_cb), source);
browserbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
/* search bar (if the source supports searching) */
if (grl_source_supported_operations (source->priv->grilo_source) & GRL_OP_SEARCH) {
source->priv->search_entry = rb_search_entry_new (FALSE);
g_object_set (source->priv->search_entry, "explicit-mode", TRUE, NULL);
g_signal_connect (source->priv->search_entry, "search", G_CALLBACK (search_cb), source);
g_signal_connect (source->priv->search_entry, "activate", G_CALLBACK (search_cb), source);
gtk_box_pack_start (GTK_BOX (browserbox), GTK_WIDGET (source->priv->search_entry), FALSE, FALSE, 6);
}
gtk_container_add (GTK_CONTAINER (scrolled), source->priv->browser_view);
gtk_box_pack_start (GTK_BOX (browserbox), scrolled, TRUE, TRUE, 0);
mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (source), mainbox, TRUE, TRUE, 0);
/* info bar */
source->priv->info_bar_label = gtk_label_new ("");
source->priv->info_bar = gtk_info_bar_new ();
gtk_info_bar_set_message_type (GTK_INFO_BAR (source->priv->info_bar), GTK_MESSAGE_INFO);
gtk_info_bar_add_button (GTK_INFO_BAR (source->priv->info_bar), _("Fetch more tracks"), GTK_RESPONSE_OK);
gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->info_bar))),
source->priv->info_bar_label);
gtk_widget_show (GTK_WIDGET (source->priv->info_bar_label));
gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->info_bar), TRUE);
g_signal_connect (source->priv->info_bar, "response", G_CALLBACK (fetch_more_cb), source);
/* don't allow the browser to be hidden? */
source->priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->entry_view), source->priv->paned, NULL);
gtk_paned_pack1 (GTK_PANED (source->priv->paned), browserbox, FALSE, FALSE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (source->priv->entry_view), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), source->priv->info_bar, FALSE, FALSE, 0);
gtk_paned_pack2 (GTK_PANED (source->priv->paned), vbox, TRUE, FALSE);
gtk_box_pack_start (GTK_BOX (mainbox), source->priv->paned, TRUE, TRUE, 0);
gtk_widget_show_all (GTK_WIDGET (source));
}
/* Create list */
static
GtkWidget* create_list(void)
{
GtkListStore *list_store;
GtkWidget *list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSortable *sortable;
GtkTreeView *list_view;
GtkTreeSelection *selection;
/* Create the store */
list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX */
G_TYPE_STRING, /* IP Address */
G_TYPE_INT, /* DATA */
G_TYPE_INT, /* INIT */
G_TYPE_INT, /* INIT_ACK */
G_TYPE_INT, /* SACK */
G_TYPE_INT, /* HEARTBEAT */
G_TYPE_INT, /* HEARTBEAT_ACK */
G_TYPE_INT, /* ABORT */
G_TYPE_INT, /* SHUTDOWN */
G_TYPE_INT, /* SHUTDOWN_ACK */
G_TYPE_INT, /* ERROR */
G_TYPE_INT, /* COOKIE_ECHO */
G_TYPE_INT, /* COOKIE_ACK */
G_TYPE_INT, /* ECNE */
G_TYPE_INT, /* CWR */
G_TYPE_INT, /* SHUT_COMPLETE */
G_TYPE_INT, /* AUTH */
G_TYPE_INT, /* NR_SACK */
G_TYPE_INT, /* ASCONF_ACK */
G_TYPE_INT, /* PKTDROP */
G_TYPE_INT, /* FORWARD_TSN */
G_TYPE_INT, /* ASCONF */
G_TYPE_INT); /* Others */
/* Create a view */
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
list_view = GTK_TREE_VIEW(list);
sortable = GTK_TREE_SORTABLE(list_store);
/* Speed up the list display */
gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
/* Setup the sortable columns */
gtk_tree_sortable_set_sort_column_id(sortable, IP_ADDR_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_view_set_headers_clickable(list_view, FALSE);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
/* 1:st column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("IP Address", renderer,
"text", IP_ADDR_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, IP_ADDR_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 135);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
/* 2:nd column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("DATA", renderer,
"text", DATA_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, DATA_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 70);
gtk_tree_view_append_column (list_view, column);
/* 3:d column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("INIT", renderer,
"text", INIT_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, INIT_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 70);
gtk_tree_view_append_column (list_view, column);
/* 4:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("INIT-ACK", renderer,
"text", INIT_ACK_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, INIT_ACK_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 90);
gtk_tree_view_append_column (list_view, column);
/* 5:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("SACK", renderer,
"text", SACK_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, SACK_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 70);
gtk_tree_view_append_column (list_view, column);
/* 6:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("HEARTBEAT", renderer,
"text", HEARTBEAT_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, HEARTBEAT_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 110);
gtk_tree_view_append_column (list_view, column);
/* 7:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("HEARTBEAT-ACK", renderer,
"text", HEARTBEAT_ACK_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, HEARTBEAT_ACK_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 140);
gtk_tree_view_append_column (list_view, column);
/* 8:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ABORT", renderer,
"text", ABORT_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, ABORT_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column (list_view, column);
/* 9:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("SHUTDOWN", renderer,
"text", SHUTDOWN_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, SHUTDOWN_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column (list_view, column);
/* 10:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("SHUTDOWN-ACK", renderer,
"text", SHUTDOWN_ACK_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, SHUTDOWN_ACK_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 150);
gtk_tree_view_append_column (list_view, column);
/* 11:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ERROR", renderer,
"text", ERROR_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, ERROR_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column (list_view, column);
/* 12:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("COOKIE-ECHO", renderer,
"text", COOKIE_ECHO_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, COOKIE_ECHO_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 130);
gtk_tree_view_append_column (list_view, column);
/* 13:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("COOKIE-ACK", renderer,
"text", COOKIE_ACK_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, COOKIE_ACK_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 130);
gtk_tree_view_append_column (list_view, column);
/* 14:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ECNE", renderer,
"text", ECNE_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, ECNE_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 70);
gtk_tree_view_append_column (list_view, column);
/* 15:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("CWR", renderer,
"text", CWR_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, CWR_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 70);
gtk_tree_view_append_column (list_view, column);
/* 16:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("SHUT-COMPLETE", renderer,
"text", SHUT_COMPLETE_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, SHUT_COMPLETE_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 150);
gtk_tree_view_append_column (list_view, column);
/* 17:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("AUTH", renderer,
"text", AUTH_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, AUTH_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column (list_view, column);
/* 18:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("NR-SACK", renderer,
"text", NR_SACK_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NR_SACK_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 19:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ASCONF-ACK", renderer,
"text", ASCONF_ACK_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, ASCONF_ACK_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column (list_view, column);
/* 20:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("PKTDROP", renderer,
"text", PKTDROP_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, PKTDROP_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 21:st column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("FORWARD-TSN", renderer,
"text", FORWARD_TSN_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, FORWARD_TSN_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 140);
gtk_tree_view_append_column (list_view, column);
/* 22:nd column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ASCONF", renderer,
"text", ASCONF_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, ASCONF_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 90);
gtk_tree_view_append_column (list_view, column);
/* 23:rd column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Others", renderer,
"text", OTHERS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, OTHERS_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column (list_view, column);
/* Now enable the sorting of each column */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
return list;
}
gint gui_contact_open_by_dial(const gchar *dial)
{
debug("gui_contact_open_by_dial\n");
store_contact_struct *contact=NULL;
store_contact_match(&contact,dial);
if(!contact)
return -1;
store_contact_load_details(contact);
GtkWidget *window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
if(contact->name)
gtk_window_set_title(GTK_WINDOW(window),contact->name);
else
gtk_window_set_title(GTK_WINDOW(window),"<Unknown>");
gtk_window_set_default_size(GTK_WINDOW(window),400,220);
GtkWidget *notebook=gtk_notebook_new();
GtkWidget *v1=gtk_vbox_new(FALSE,0);
GtkWidget *title_bar=gtk_hbox_new(FALSE,0);
GdkPixbuf *pixbuf=NULL;
if(contact->name==NULL && contact->picture==NULL)
pixbuf=utils_get_photo_unknown();
else if(contact->picture==NULL)
pixbuf=utils_get_photo_default();
else
pixbuf=utils_get_photo(contact->picture);
GtkWidget *picture=gtk_image_new_from_pixbuf(pixbuf);
GtkWidget *name;
if(contact->name){
name=gtk_label_new (contact->name);
}else{
name=gtk_label_new ("<Unknown>");
}
gtk_box_pack_start(GTK_BOX(title_bar), picture, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(title_bar), name, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(v1), title_bar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(v1), gtk_hseparator_new(), FALSE, FALSE, 5);
GList *dials=contact->dials;
debug("Dials %p\n",dials);
while(dials){
gchar *dial=((store_dial_struct*)dials->data)->dial;
GtkWidget *label=gtk_label_new(dial);
GtkWidget *button_sms=gtk_button_new ();
GtkWidget *button_voice=gtk_button_new ();
GtkWidget *h_dial=gtk_hbox_new(FALSE,0);
GtkWidget *sms=gtk_image_new_from_pixbuf(utils_get_icon("sms.png"));
GtkWidget *voice=gtk_image_new_from_pixbuf(utils_get_icon("voice.png"));
g_signal_connect(G_OBJECT(button_sms),"clicked", G_CALLBACK(gui_contact_send_sms_callback),label);
g_signal_connect(G_OBJECT(button_voice),"clicked", G_CALLBACK(gui_contact_dial_callback),label);
gtk_container_add (GTK_CONTAINER(button_sms),sms);
gtk_container_add (GTK_CONTAINER(button_voice),voice);
gtk_misc_set_alignment(GTK_MISC(label),0,0.5);
debug("gui_contact_open_by_dial add dial %d\n",dial);
gtk_box_pack_start(GTK_BOX(h_dial), label, TRUE, TRUE, 20);
gtk_box_pack_start(GTK_BOX(h_dial), button_sms, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(h_dial), button_voice, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(v1), h_dial, FALSE, FALSE, 0);
dials=g_list_next(dials);
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Details"));
// Call history
GtkWidget *scroll;
GtkWidget *calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_STATUS, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Duration", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_CALL_DURACTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
//g_signal_connect_after(G_OBJECT(g_gui_calls.dials_view),"cursor-changed", G_CALLBACK(gui_dialer_book_click_callback),NULL);
SphoneStoreTreeModel *calls;
if(contact->name!=NULL){ // known contact
gchar contactid[20];
sprintf(contactid,"%d",contact->id);
debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID query='%s'\n",contactid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_CONTACT_ID, contactid);
}else{
gchar dialid[20];
sprintf(dialid,"%d",store_dial_get_id(dial));
debug("SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID query='%s'\n",dialid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_CALLS_MATCH_DIAL_ID, dialid);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),scroll,gtk_label_new("Calls"));
// SMS history
v1=gtk_vbox_new(FALSE,0);
calls_view = gtk_tree_view_new();
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(calls_view),TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(calls_view),TRUE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Dir", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DIRECTION, NULL);
gtk_tree_view_column_set_fixed_width(column,70);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Dial", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_DIAL, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_DATE, NULL);
gtk_tree_view_column_set_fixed_width(column,80);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new_with_attributes("Text", renderer, "text", SPHONE_STORE_TREE_MODEL_COLUMN_INTERACTION_SMS_TEXT, NULL);
gtk_tree_view_column_set_expand(column,TRUE);
gtk_tree_view_column_set_sizing(column,GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(calls_view), column);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(calls_view),TRUE);
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER(scroll),calls_view);
GtkWidget *sms_content=gtk_label_new (NULL);
gtk_label_set_selectable(GTK_LABEL(sms_content), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(sms_content), TRUE);
g_signal_connect_after(G_OBJECT(calls_view),"cursor-changed", G_CALLBACK(gui_contact_sms_selected_callback),sms_content);
if(contact->name!=NULL){ // known contact
gchar contactid[20];
sprintf(contactid,"%d",contact->id);
debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID query='%s'\n",contactid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_CONTACT_ID, contactid);
}else{
gchar dialid[20];
sprintf(dialid,"%d",store_dial_get_id(dial));
debug("SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID query='%s'\n",dialid);
calls = sphone_store_tree_model_new(&SPHONE_STORE_TREE_MODEL_FILTER_SMS_MATCH_DIAL_ID, dialid);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(calls_view), GTK_TREE_MODEL(calls));
g_object_unref(G_OBJECT(calls));
gtk_container_add (GTK_CONTAINER(v1),scroll);
gtk_container_add (GTK_CONTAINER(v1),sms_content);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),v1,gtk_label_new("Messages"));
gtk_container_add(GTK_CONTAINER(window),notebook);
gtk_widget_show_all(window);
store_contact_free(contact);
return 0;
}
bool gtkui_archive_handle(const char *filename, char *reqfile, size_t reqsize) {
// Select a filename to pull out of the archive
struct archive *a;
struct archive_entry *entry;
int r, numarchives = 0;
cancelled = false;
a = archive_read_new();
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
r = archive_read_open_filename(a, filename, 10240);
// Test if it's actually an archive
if (r != ARCHIVE_OK) {
r = archive_read_free(a);
return false;
}
// If it is an archive, handle it
else {
// Don't try to bring up a GUI selector if the GUI is disabled
if (conf.misc_disable_gui) {
// Fill the treestore with the filenames
while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
const char *currentfile = archive_entry_pathname(entry);
if (nst_archive_checkext(currentfile)) {
snprintf(reqfile, reqsize, "%s", currentfile);
break;
}
}
archive_read_data_skip(a);
// Free the archive
r = archive_read_free(a);
return true;
}
// Set up the archive window
GtkTreeIter iter;
GtkTreeModel *model;
GtkTreeSelection *selection;
archivewindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(archivewindow), "Choose File from Archive");
gtk_window_set_modal(GTK_WINDOW(archivewindow), TRUE);
GtkWidget *archivebox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(archivewindow), archivebox);
gtk_widget_show(archivebox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(archivebox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 340, 340);
gtk_widget_show(scrolledwindow);
GtkWidget *buttonbox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(archivebox), buttonbox, FALSE, TRUE, 0);
gtk_widget_show(buttonbox);
GtkWidget *treeview = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER(scrolledwindow), treeview);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (treeview), FALSE);
gtk_widget_show(treeview);
GtkTreeStore *treestore = gtk_tree_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(treestore));
// Fill the treestore with the filenames
while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
const char *currentfile = archive_entry_pathname(entry);
if (nst_archive_checkext(currentfile)) {
gtk_tree_store_append(treestore, &iter, NULL);
gtk_tree_store_set(treestore, &iter, 0, currentfile, -1);
numarchives++;
snprintf(reqfile, reqsize, "%s", currentfile);
}
archive_read_data_skip(a);
}
// Free the archive
r = archive_read_free(a);
// If there are no valid files in the archive, return
if (numarchives == 0) { return false; }
// If there's only one file, don't bring up the selector
else if (numarchives == 1) { return true; }
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes(
"NES file",
renderer,
"text", 0,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (treeview), column);
GtkWidget *cancelbutton = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_CANCEL,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(cancelbutton), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), cancelbutton, FALSE, FALSE, 0);
gtk_widget_show(cancelbutton);
GtkWidget *okbutton = gtk_widget_new(
GTK_TYPE_BUTTON,
"label", GTK_STOCK_OK,
"halign", GTK_ALIGN_END,
"margin-top", 8,
"margin-bottom", 8,
"margin-right", 8,
NULL);
gtk_button_set_use_stock(GTK_BUTTON(okbutton), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), okbutton, FALSE, FALSE, 0);
gtk_widget_show(okbutton);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
g_signal_connect(G_OBJECT(okbutton), "clicked",
G_CALLBACK(gtkui_archive_ok), NULL);
g_signal_connect(G_OBJECT(cancelbutton), "clicked",
G_CALLBACK(gtkui_archive_cancel), NULL);
g_signal_connect(G_OBJECT(treeview), "row-activated",
G_CALLBACK(gtkui_archive_ok), NULL);
g_signal_connect(G_OBJECT(archivewindow), "destroy",
G_CALLBACK(gtkui_archive_cancel), NULL);
gtk_widget_show(archivewindow);
// Freeze the rest of the program until a selection is made
windowopen = true;
while (windowopen) {
gtk_main_iteration_do(TRUE);
if (cancelled) { return false; }
}
gchar *reqbuf;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_get_selected(selection, &model, &iter);
gtk_tree_model_get(model, &iter, 0, &reqbuf, -1);
gtk_widget_destroy(archivewindow);
snprintf(reqfile, reqsize, "%s", reqbuf);
return true;
}
return false;
}
static
GtkWidget *create_list(void)
{
GtkListStore *list_store;
GtkWidget * list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeView *list_view;
GtkTreeSelection *selection;
list_store = gtk_list_store_new(N_COLUMN,
G_TYPE_UINT, /* Port1*/
G_TYPE_UINT, /* Port2*/
G_TYPE_UINT, /* number of packets */
G_TYPE_STRING, /* checksum type */
G_TYPE_UINT, /* number of checksum errors */
G_TYPE_UINT, /* number of data chunks */
G_TYPE_UINT, /* number of data bytes */
G_TYPE_UINT, /* vtag1 */
G_TYPE_UINT); /* vtag2 */
/* Create a view */
list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list_store));
list_view = GTK_TREE_VIEW(list);
/* Speed up the list display */
gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
gtk_tree_view_set_headers_clickable(list_view, TRUE);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref(G_OBJECT(list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
/* 1:st column */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Port 1", renderer,
"text", PORT1_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, PORT1_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
/* Add the column to the view. */
gtk_tree_view_append_column(list_view, column);
/* 2:nd column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Port 2", renderer,
"text", PORT2_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, PORT2_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column(list_view, column);
/* 3:d column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("No of Packets", renderer,
"text", PACKETS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, PACKETS_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column(list_view, column);
/* 4:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Checksum", renderer,
"text", CHECKSUM_TYPE_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, CHECKSUM_TYPE_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column(list_view, column);
/* 5:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("No of Errors", renderer,
"text", CHECKSUM_ERRORS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, CHECKSUM_ERRORS_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column(list_view, column);
/* 6:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Data Chunks", renderer,
"text", DATA_CHUNKS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, DATA_CHUNKS_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column(list_view, column);
/* 7:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Data Bytes", renderer,
"text", DATA_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, DATA_BYTES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column(list_view, column);
/* 8:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("VTag 1", renderer,
"text", VTAG1_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, VTAG1_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column(list_view, column);
/* 9:th column... */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("VTag 2", renderer,
"text", VTAG2_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, VTAG2_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 120);
gtk_tree_view_append_column(list_view, column);
/* Now enable the sorting of each column */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(selection, "changed", G_CALLBACK(sctp_stat_on_select_row), NULL);
return list;
}
/* Create list */
static
GtkWidget* create_list(void)
{
GtkListStore *list_store;
GtkWidget *list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSortable *sortable;
GtkTreeView *list_view;
GtkTreeSelection *selection;
/* Create the store */
list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/
G_TYPE_UINT, /* ID */
G_TYPE_STRING, /* Operation Code */
G_TYPE_INT, /* Invokes */
G_TYPE_INT, /* Num Bytes */
G_TYPE_FLOAT, /* Avg Bytes */
G_TYPE_INT, /* RetResult */
G_TYPE_INT, /* Num Bytes */
G_TYPE_FLOAT, /* Avg Bytes */
G_TYPE_INT, /* Total Bytes */
G_TYPE_FLOAT); /* Avg Bytes */
/* Create a view */
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
list_view = GTK_TREE_VIEW(list);
sortable = GTK_TREE_SORTABLE(list_store);
/* Speed up the list display */
gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
/* Setup the sortable columns */
gtk_tree_sortable_set_sort_column_id(sortable, ID_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_view_set_headers_clickable(list_view, FALSE);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
/* 1:st column */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ID", renderer,
"text", ID_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, ID_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 40);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
/* 2:nd column..Operation Code. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Operation Code", renderer,
"text", OP_CODE_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, OP_CODE_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 210);
gtk_tree_view_append_column (list_view, column);
/* 3:d column..Invokes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Invokes", renderer,
"text", INVOKES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, INVOKES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 60);
gtk_tree_view_append_column (list_view, column);
/* 4:th column.. Num Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
"text", NUM_BYTES_FWD_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 5:th column.. Avg Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
"text", AVG_BYTES_FWD_COLUMN,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
GINT_TO_POINTER(AVG_BYTES_FWD_COLUMN), NULL);
gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_FWD_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column (list_view, column);
/* 6:d column..Invokes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("ReturnResult", renderer,
"text", RET_RES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, RET_RES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 60);
gtk_tree_view_append_column (list_view, column);
/* 7:th column.. Num Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
"text", NUM_BYTES_REV_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 8:th column.. Avg Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
"text", AVG_BYTES_REV_COLUMN,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
GINT_TO_POINTER(AVG_BYTES_REV_COLUMN), NULL);
gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_REV_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column (list_view, column);
/* 9:th column.. Total Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Total Bytes", renderer,
"text", TOT_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 100);
gtk_tree_view_append_column (list_view, column);
/* 10:th column.. Avg Bytes. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
"text", AVG_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
GINT_TO_POINTER(AVG_BYTES_COLUMN), NULL);
gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 60);
gtk_tree_view_append_column (list_view, column);
/* Now enable the sorting of each column */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
return list;
}
/* Create list */
static
GtkWidget* create_list(void)
{
GtkListStore *list_store;
GtkWidget *list;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSortable *sortable;
GtkTreeView *list_view;
GtkTreeSelection *selection;
/* Create the store */
list_store = gtk_list_store_new(N_COLUMN, /* Total number of columns XXX*/
G_TYPE_UINT, /* IEI */
G_TYPE_STRING, /* Message Name */
G_TYPE_UINT); /* Count */
/* Create a view */
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));
list_view = GTK_TREE_VIEW(list);
sortable = GTK_TREE_SORTABLE(list_store);
/* Speed up the list display */
gtk_tree_view_set_fixed_height_mode(list_view, TRUE);
/* Setup the sortable columns */
gtk_tree_sortable_set_sort_column_id(sortable, IEI_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_view_set_headers_clickable(list_view, FALSE);
/* The view now holds a reference. We can get rid of our own reference */
g_object_unref (G_OBJECT (list_store));
/*
* Create the first column packet, associating the "text" attribute of the
* cell_renderer to the first column of the model
*/
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("IEI", renderer,
"text", IEI_COLUMN,
NULL);
/* gtk_tree_view_column_set_cell_data_func(column, renderer, present_as_hex_func,
GINT_TO_POINTER(IEI_COLUMN), NULL);
*/
gtk_tree_view_column_set_sort_column_id(column, IEI_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 50);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
/* Second column.. Message Name. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Message Name", renderer,
"text", MSG_NAME_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, MSG_NAME_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 280);
gtk_tree_view_append_column (list_view, column);
/* Third column.. Count. */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Count", renderer,
"text", COUNT_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, COUNT_COLUMN);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width(column, 50);
gtk_tree_view_append_column (list_view, column);
/* Now enable the sorting of each column */
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);
/* Setup the selection handler */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
return list;
}
gboolean completion_create(GtkTreeModel *model, CompletionSelectFunc selfunc,
gboolean back)
{
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkRequisition size;
GtkTreePath *path;
GtkTreeIter iter;
int height, width;
/* if there is only one match - don't build the tree view */
if (gtk_tree_model_iter_n_children(model, NULL) == 1) {
char *value;
path = gtk_tree_path_new_from_indices(0, -1);
if (gtk_tree_model_get_iter(model, &iter, path)) {
gtk_tree_model_get(model, &iter, COMPLETION_STORE_FIRST, &value, -1);
/* call the select function */
selfunc(value);
g_free(value);
g_object_unref(model);
return false;
}
}
comp.selfunc = selfunc;
/* prepare the tree view */
comp.win = gtk_scrolled_window_new(NULL, NULL);
comp.tree = gtk_tree_view_new();
#ifndef HAS_GTK3
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comp.win), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
#endif
gtk_box_pack_end(GTK_BOX(vb.gui.box), comp.win, false, false, 0);
gtk_container_add(GTK_CONTAINER(comp.win), comp.tree);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(comp.tree), false);
/* we have only on line per item so we can use the faster fixed heigh mode */
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(comp.tree), true);
gtk_tree_view_set_model(GTK_TREE_VIEW(comp.tree), model);
g_object_unref(model);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_fg[VB_COMP_NORMAL]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_bg[VB_COMP_NORMAL]);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_fg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_bg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_fg[VB_COMP_ACTIVE]);
VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_bg[VB_COMP_ACTIVE]);
/* prepare the selection */
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(comp.tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_tree_selection_set_select_function(selection, tree_selection_func, NULL, NULL);
/* get window dimension */
gtk_window_get_size(GTK_WINDOW(vb.gui.window), &width, &height);
/* prepare first column */
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,
"font-desc", vb.style.comp_font,
"ellipsize", PANGO_ELLIPSIZE_MIDDLE,
NULL
);
gtk_tree_view_column_pack_start(column, renderer, true);
gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_FIRST);
gtk_tree_view_column_set_min_width(column, 2 * width/3);
/* prepare second column */
#ifdef FEATURE_TITLE_IN_COMPLETION
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer,
"font-desc", vb.style.comp_font,
"ellipsize", PANGO_ELLIPSIZE_END,
NULL
);
gtk_tree_view_column_pack_start(column, renderer, true);
gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_SECOND);
#endif
/* to set the height for the treeview the tree must be realized first */
gtk_widget_show(comp.tree);
/* this prevents the first item to be placed out of view if the completion
* is shown */
while (gtk_events_pending()) {
gtk_main_iteration();
}
/* use max 1/3 of window height for the completion */
#ifdef HAS_GTK3
gtk_widget_get_preferred_size(comp.tree, NULL, &size);
height /= 3;
gtk_scrolled_window_set_min_content_height(
GTK_SCROLLED_WINDOW(comp.win),
size.height > height ? height : size.height
);
#else
gtk_widget_size_request(comp.tree, &size);
height /= 3;
if (size.height > height) {
gtk_widget_set_size_request(comp.win, -1, height);
}
#endif
vb.mode->flags |= FLAG_COMPLETION;
/* set to -1 to have the cursor on first or last item set in move_cursor */
comp.active = -1;
completion_next(back);
gtk_widget_show(comp.win);
return true;
}
static void
_dtv_init (DiagramTreeView *dtv)
{
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gint font_size;
GtkStyle *style;
/* connect the model with the view */
gtk_tree_view_set_model (GTK_TREE_VIEW (dtv), diagram_tree_model_new ());
gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (dtv), TRUE);
/* the tree requires reading across rows (semantic hint) */
#if 0 /* stripe style */
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dtv), TRUE);
#endif
style = gtk_widget_get_style (GTK_WIDGET (dtv));
font_size = pango_font_description_get_size (style->font_desc);
font_size = PANGO_PIXELS (font_size);
/* first colum: name of diagram/layer/object - here is the tree */
cell = gtk_cell_renderer_text_new ();
gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (cell), 1);
g_object_set (cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_min_width (column, font_size * 10);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "text", NAME_COLUMN);
gtk_tree_view_insert_column (GTK_TREE_VIEW (dtv), column, -1);
/* this is enough for simple name search (just typing) */
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dtv), NAME_COLUMN);
/* must have a sortable model ... */
gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN);
/* type column - show the type icon */
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Type"));
/* must have fixed size, too */
gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED);
/* without it gets zero size - not very useful! */
gtk_tree_view_column_set_min_width (column, font_size * 6);
gtk_tree_view_column_set_resizable (column, TRUE);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (column), cell, TRUE);
gtk_cell_layout_set_cell_data_func (GTK_CELL_LAYOUT (column), cell,
_dtv_cell_pixbuf_func, dtv, NULL);
gtk_tree_view_insert_column (GTK_TREE_VIEW (dtv), column, -1);
gtk_tree_view_column_set_sort_column_id (column, OBJECT_COLUMN);
/* TODO: other fancy stuff */
{
GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dtv));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_rubber_banding (GTK_TREE_VIEW (dtv), TRUE);
}
gtk_widget_set_has_tooltip (GTK_WIDGET (dtv), TRUE);
_dtv_create_popup_menu (dtv);
}
