/**
* Create a new GtkTreeView for search results.
*/
GtkWidget *
search_gui_create_tree(void)
{
GtkTreeModel *model = create_results_model();
GtkTreeSelection *selection;
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gtk_tree_view_new_with_model(model));
g_object_unref(model);
selection = gtk_tree_view_get_selection(tv);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_headers_clickable(tv, TRUE);
gtk_tree_view_set_headers_visible(tv, TRUE);
gtk_tree_view_set_enable_search(tv, TRUE);
gtk_tree_view_set_search_column(tv, 0);
gtk_tree_view_set_rules_hint(tv, TRUE);
gtk_tree_view_set_search_equal_func(tv, search_by_regex, NULL, NULL);
tree_view_set_fixed_height_mode(tv, TRUE);
/* add columns to the tree view */
add_results_columns(tv);
tree_view_restore_visibility(tv, PROP_SEARCH_RESULTS_COL_VISIBLE);
tree_view_restore_widths(tv, PROP_SEARCH_RESULTS_COL_WIDTHS);
gui_signal_connect(tv,
"cursor-changed", on_tree_view_search_results_select_row, tv);
gui_signal_connect(tv, "leave-notify-event", on_leave_notify, NULL);
return GTK_WIDGET(tv);
}
static void
treeview_download_files_init(void)
{
GtkTreeView *tv;
unsigned i;
STATIC_ASSERT(FILEINFO_VISIBLE_COLUMNS == c_fi_num);
tv = GTK_TREE_VIEW(gtk_tree_view_new());
treeview_download_files = tv;
for (i = 0; i < c_fi_num; i++) {
add_column(tv, i,
fi_gui_files_column_title(i),
fi_gui_files_column_justify_right(i) ? 1.0 : 0.0,
c_fi_progress == i ? gtk_cell_renderer_progress_new() : NULL,
render_files);
}
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv),
GTK_SELECTION_MULTIPLE);
gtk_tree_view_set_headers_visible(tv, TRUE);
gtk_tree_view_set_headers_clickable(tv, TRUE);
gtk_tree_view_set_enable_search(tv, FALSE);
gtk_tree_view_set_rules_hint(tv, TRUE);
tree_view_set_fixed_height_mode(tv, TRUE);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_files));
tree_view_restore_visibility(tv, PROP_FILE_INFO_COL_VISIBLE);
tree_view_restore_widths(tv, PROP_FILE_INFO_COL_WIDTHS);
gui_signal_connect(tv,
"cursor-changed", on_treeview_download_files_cursor_changed, NULL);
}
//! pembuatan view
GtkWidget *tableCreate (void){
table = struct_new(table_);
databaseCreate();
GtkTreeModel *model;
table->view = gtk_tree_view_new();
//header
GtkTreeViewColumn *col = tableCreateHeader(table->view);
/* connect a cell data function */
model = create_and_fill_model("");
gtk_tree_view_set_model(GTK_TREE_VIEW(table->view), model);
g_object_unref(model); /* destroy model automatically with view */
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(table->view)),GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_clickable (table->view,TRUE);
gtk_tree_view_set_rules_hint (table->view,TRUE);
gtk_tree_view_set_grid_lines(table->view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL );
g_object_set( table->view ,"hover-selection" , TRUE,NULL);
g_signal_connect(table->view, "button-press-event", (GCallback) table_onButtonPressed, NULL);
return table->view;
}
static void
chatrooms_window_model_add_columns (EmpathyChatroomsWindow *window)
{
GtkTreeView *view;
GtkTreeModel *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gint count;
view = GTK_TREE_VIEW (window->treeview);
model = gtk_tree_view_get_model (view);
gtk_tree_view_set_headers_visible (view, TRUE);
gtk_tree_view_set_headers_clickable (view, TRUE);
/* Name & Status */
column = gtk_tree_view_column_new ();
count = gtk_tree_view_append_column (view, column);
gtk_tree_view_column_set_title (column, _("Name"));
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_sort_column_id (column, count - 1);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell, "icon-name", COL_IMAGE);
cell = gtk_cell_renderer_text_new ();
g_object_set (cell,
"xpad", 4,
"ypad", 1,
NULL);
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell, "text", COL_NAME);
/* Room */
cell = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Room"), cell,
"text", COL_ROOM,
NULL);
count = gtk_tree_view_append_column (view, column);
gtk_tree_view_column_set_sort_column_id (column, count - 1);
window->room_column = count - 1;
/* Chatroom auto connect */
cell = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes (_("Auto-Connect"), cell,
"active", COL_AUTO_CONNECT,
NULL);
count = gtk_tree_view_append_column (view, column);
gtk_tree_view_column_set_sort_column_id (column, count - 1);
g_signal_connect (cell, "toggled",
G_CALLBACK (chatrooms_window_model_cell_auto_connect_toggled),
window);
/* Sort model */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model), 0,
GTK_SORT_ASCENDING);
}
static void trg_tree_view_init(TrgTreeView * tv)
{
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(tv), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tv), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tv), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection
(GTK_TREE_VIEW(tv)),
GTK_SELECTION_MULTIPLE);
gtk_widget_set_sensitive(GTK_WIDGET(tv), FALSE);
}
GtkTreeView *
create_stat_table(GtkWidget *scrolled_window, GtkWidget *vbox, int columns, const stat_column *headers)
{
GtkTreeView *table;
GtkListStore *store;
GtkWidget *tree;
GtkTreeViewColumn *column;
GtkTreeSelection *sel;
GtkCellRenderer *renderer;
GType *types;
int i;
if (columns <= 0)
return NULL;
types = g_malloc(columns *sizeof(GType));
for (i = 0; i < columns; i++)
types[i] = headers[i].type;
store = gtk_list_store_newv (columns, types);
g_free(types);
/* create table */
tree = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
table = GTK_TREE_VIEW(tree);
g_object_unref (G_OBJECT (store));
for (i = 0; i < columns; i++) {
renderer = gtk_cell_renderer_text_new ();
if (headers[i].align == RIGHT) {
/* right align */
g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
}
g_object_set(renderer, "ypad", 0, NULL);
column = gtk_tree_view_column_new_with_attributes (headers[i].title, renderer, "text",
i, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column (table, column);
}
gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET (table));
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
/* configure TreeView */
gtk_tree_view_set_rules_hint(table, FALSE);
gtk_tree_view_set_headers_clickable(table, FALSE);
sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(table));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
gtk_widget_show(scrolled_window);
return table;
}
static void create_clist(GtkWidget * clist_wnd)
{
GtkTreeView *view = GTK_TREE_VIEW(clist_wnd);
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *sel;
gint i;
list = gtk_list_store_new(COLUMN_NUMBER,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_INT);
model = GTK_TREE_MODEL(list);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Varname"),
renderer, "text",
COLUMN_VAR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Attribute"),
renderer, "text",
COLUMN_ATTR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Filename"),
renderer, "text",
COLUMN_FILE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1,
_("Action"),
renderer, "text",
COLUMN_ACTION, NULL);
for (i = 0; i < CLIST_NVCOLS - 1; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
}
sel = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(sel, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(sel, select_function, NULL, NULL);
}
GtkWidget* create_i2c_view()
{
int i = 0;
int loc_i;
int num_cols = I2C_NUM_COLS + mix_number_of_i2c_headers() - 1;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *view;
view = gtk_tree_view_new();
// --- Column #X ---
while(i < num_cols) {
col = gtk_tree_view_column_new();
loc_i = i > I2C_B ? I2C_B : i;
gtk_tree_view_column_set_spacing(col, 1);
gtk_tree_view_column_set_title(col, header[loc_i].title);
// pack tree view column into tree view
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "editable", header[loc_i].editable, NULL);
g_object_set_data(G_OBJECT(renderer), "column_index", GUINT_TO_POINTER(i));
g_signal_connect(renderer, "edited", (GCallback) i2c_edited_callback, NULL);
// pack cell renderer into tree view column
gtk_tree_view_column_pack_start(col, renderer, TRUE);
// connect 'text' property of the cell renderer to
// model column that contains the first name
gtk_tree_view_column_add_attribute(col, renderer, header[loc_i].type, i);
i++;
}
i2c_model = (GtkTreeModel*) create_i2c_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(view), i2c_model);
g_object_unref(i2c_model); // destroy model automatically with view
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(view), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(view), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_MULTIPLE);
return view;
}
static GtkListStore* clist_create(GtkWidget *clist)
{
GtkTreeView *view = GTK_TREE_VIEW(clist);
GtkListStore *list;
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gint i;
const gchar *text[CLIST_NCOLS] = {
_("Filename"), _("Model"), _("Version"),
_("Type"), _("Size"), _("Boot"), _("Hardware") };
list = gtk_list_store_new(CLIST_NCOLS,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING,
-1);
model = GTK_TREE_MODEL(list);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
for (i = 0; i < CLIST_NCOLS; i++)
{
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, text[i],
renderer, "text", i, NULL);
}
for (i = 0; i < CLIST_NCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(clist_selection_changed), NULL);
return list;
}
static void
mug_msg_list_view_init (MugMsgListView * obj)
{
MugMsgListViewPrivate *priv;
GtkTreeView *tview;
priv = MUG_MSG_LIST_VIEW_GET_PRIVATE (obj);
priv->_xpath = priv->_query = NULL;
priv->_store = gtk_list_store_new (MUG_N_COLS, G_TYPE_STRING, /* date */
G_TYPE_STRING, /* folder */
G_TYPE_STRING, /* flagstr */
G_TYPE_STRING, /* from */
G_TYPE_STRING, /* to */
G_TYPE_STRING, /* subject */
G_TYPE_STRING, /* path */
G_TYPE_UINT, /* prio */
G_TYPE_UINT, /* flags */
G_TYPE_INT); /* timeval */
tview = GTK_TREE_VIEW (obj);
gtk_tree_view_set_model (tview, GTK_TREE_MODEL (priv->_store));
gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (obj), TRUE);
gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (obj),
GTK_TREE_VIEW_GRID_LINES_VERTICAL);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (obj), TRUE);
append_col (tview, "Date", MUG_COL_DATESTR, MUG_COL_TIME, 80);
append_col (tview, "Folder", MUG_COL_MAILDIR, -1, 60);
append_col (tview, "F", MUG_COL_FLAGSSTR, -1, 25);
append_col (tview, "From", MUG_COL_FROM, -1, 0);
append_col (tview, "To", MUG_COL_TO, -1, 0);
append_col (tview, "Subject", MUG_COL_SUBJECT, -1, 0);
g_signal_connect (G_OBJECT (obj), "cursor-changed",
G_CALLBACK (on_cursor_changed), obj);
}
void create_romBrowser()
{
GtkWidget* menu;
GtkWidget* submenu;
GtkWidget* item;
australia = gdk_pixbuf_new_from_file(get_iconpath("australia.png"), NULL);
europe = gdk_pixbuf_new_from_file(get_iconpath("europe.png"), NULL);
france = gdk_pixbuf_new_from_file(get_iconpath("france.png"), NULL);
germany = gdk_pixbuf_new_from_file(get_iconpath("germany.png"), NULL);
italy = gdk_pixbuf_new_from_file(get_iconpath("italy.png"), NULL);
japan = gdk_pixbuf_new_from_file(get_iconpath("japan.png"), NULL);
spain = gdk_pixbuf_new_from_file(get_iconpath("spain.png"), NULL);
usa = gdk_pixbuf_new_from_file(get_iconpath("usa.png"), NULL);
japanusa = gdk_pixbuf_new_from_file(get_iconpath("japanusa.png"), NULL);
n64cart = gdk_pixbuf_new_from_file(get_iconpath("16x16/mupen64cart.png"), NULL);
/* Setup rombrowser column names.
g_MainWindow.column_names[column][0] is the translated column header.
g_MainWindow.column_names[column][1] toggles visability in the config system. */
snprintf(g_MainWindow.column_names[0][0], 128, tr("Country"));
snprintf(g_MainWindow.column_names[0][1], 128, "ColumnCountryVisible");
snprintf(g_MainWindow.column_names[1][0], 128, tr("Good Name"));
snprintf(g_MainWindow.column_names[1][1], 128, "ColumnGoodNameVisible");
snprintf(g_MainWindow.column_names[2][0], 128, tr("Status"));
snprintf(g_MainWindow.column_names[2][1], 128, "ColumnStatusVisible");
snprintf(g_MainWindow.column_names[3][0], 128, tr("User Comments"));
snprintf(g_MainWindow.column_names[3][1], 128, "ColumnUserCommentsVisible");
snprintf(g_MainWindow.column_names[4][0], 128, tr("File Name"));
snprintf(g_MainWindow.column_names[4][1], 128, "ColumnFileNameVisible");
snprintf(g_MainWindow.column_names[5][0], 128, tr("MD5 Hash"));
snprintf(g_MainWindow.column_names[5][1], 128, "ColumnMD5HashVisible");
snprintf(g_MainWindow.column_names[6][0], 128, tr("CRC1"));
snprintf(g_MainWindow.column_names[6][1], 128, "ColumnCRC1Visible");
snprintf(g_MainWindow.column_names[7][0], 128, tr("CRC2"));
snprintf(g_MainWindow.column_names[7][1], 128, "ColumnCRC2Visible");
snprintf(g_MainWindow.column_names[8][0], 128, tr("Internal Name"));
snprintf(g_MainWindow.column_names[8][1], 128, "ColumnInternalNameVisible");
snprintf(g_MainWindow.column_names[9][0], 128, tr("Save Types"));
snprintf(g_MainWindow.column_names[9][1], 128, "ColumnSaveTypeVisible");
snprintf(g_MainWindow.column_names[10][0], 128, tr("Players"));
snprintf(g_MainWindow.column_names[10][1], 128, "ColumnPlayersVisible");
snprintf(g_MainWindow.column_names[11][0], 128, tr("Size"));
snprintf(g_MainWindow.column_names[11][1], 128, "ColumnSizeVisible");
snprintf(g_MainWindow.column_names[12][0], 128, tr("Compression"));
snprintf(g_MainWindow.column_names[12][1], 128, "ColumnCompressionVisible");
snprintf(g_MainWindow.column_names[13][0], 128, tr("Image Type"));
snprintf(g_MainWindow.column_names[13][1], 128, "ColumnImageTypeVisible");
snprintf(g_MainWindow.column_names[14][0], 128, tr("CIC Chip"));
snprintf(g_MainWindow.column_names[14][1], 128, "ColumnCICChipVisible");
snprintf(g_MainWindow.column_names[15][0], 128, tr("Rumble"));
snprintf(g_MainWindow.column_names[15][1], 128, "ColumnRumbleVisible");
/* Setup rombrowser tree views. */
g_MainWindow.romFullList = gtk_tree_view_new();
g_MainWindow.romDisplay = gtk_tree_view_new();
/* Multiple selections needed due to the way we clear the TreeViews. */
GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_MainWindow.romFullList));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(g_MainWindow.romDisplay));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
/* Initialize TreeViews - i.e. setup column info. models */
setup_view(g_MainWindow.romFullList);
setup_view(g_MainWindow.romDisplay);
g_MainWindow.romScrolledWindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(g_MainWindow.romScrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
/* Add the Display TreeView into our scrolled window. */
gtk_container_add(GTK_CONTAINER(g_MainWindow.romScrolledWindow), g_MainWindow.romDisplay);
gtk_container_add(GTK_CONTAINER(g_MainWindow.toplevelVBox), g_MainWindow.romScrolledWindow);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(g_MainWindow.romDisplay), TRUE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(g_MainWindow.romDisplay), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(g_MainWindow.romDisplay), FALSE);
/* Open on double click. */
g_signal_connect(g_MainWindow.romDisplay, "row-activated", G_CALLBACK(callback_play_rom), NULL);
/* Setup right-click menu. */
menu = gtk_menu_new();
g_MainWindow.playRomItem = gtk_image_menu_item_new_with_label(tr("Play Rom"));
g_MainWindow.playRombrowserImage = gtk_image_new();
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(g_MainWindow.playRomItem), g_MainWindow.playRombrowserImage);
g_signal_connect(g_MainWindow.playRomItem, "activate", G_CALLBACK(callback_play_rom), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), g_MainWindow.playRomItem);
g_MainWindow.romPropertiesItem = gtk_image_menu_item_new_with_label(tr("Rom Properties"));
g_MainWindow.propertiesRombrowserImage = gtk_image_new();
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(g_MainWindow.romPropertiesItem), g_MainWindow.propertiesRombrowserImage);
g_signal_connect(g_MainWindow.romPropertiesItem, "activate", G_CALLBACK(callback_rom_properties), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), g_MainWindow.romPropertiesItem);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
item = gtk_image_menu_item_new_with_label(tr("Refresh"));
g_MainWindow.refreshRombrowserImage = gtk_image_new();
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), g_MainWindow.refreshRombrowserImage);
g_signal_connect(item, "activate", G_CALLBACK(callback_call_rcs), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
item = gtk_menu_item_new_with_label(tr("Configure Rombrowser"));
g_signal_connect(item, "activate", G_CALLBACK(callback_configure_rombrowser), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
submenu = gtk_image_menu_item_new_with_label(tr("Configure Columns"));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu), g_MainWindow.romHeaderMenu);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), submenu);
gtk_widget_show_all(menu);
g_signal_connect(g_MainWindow.romDisplay, "button-press-event", G_CALLBACK(callback_rombrowser_context), (gpointer)menu);
}
void ModelInfoTab::populateTab() {
// Set the outer space of the vbox
gtk_container_set_border_width(GTK_CONTAINER(_widget), 12);
// Create the list store that contains the model => info map
_listStore = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT);
// Create the treeview and pack two columns into it
_treeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(_listStore));
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(_treeView), TRUE);
GtkTreeViewColumn* modelCol = gtkutil::TextColumn(_("Model"), MODEL_COL);
gtk_tree_view_column_set_sort_column_id(modelCol, MODEL_COL);
GtkTreeViewColumn* polyCountCol = gtkutil::TextColumn(_("Polys"), POLYCOUNT_COL);
gtk_tree_view_column_set_sort_column_id(polyCountCol, POLYCOUNT_COL);
GtkTreeViewColumn* modelCountCol = gtkutil::TextColumn(_("Count"), MODELCOUNT_COL);
gtk_tree_view_column_set_sort_column_id(modelCountCol, MODELCOUNT_COL);
GtkTreeViewColumn* skinCountCol = gtkutil::TextColumn(_("Skins"), SKINCOUNT_COL);
gtk_tree_view_column_set_sort_column_id(skinCountCol, SKINCOUNT_COL);
gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView), modelCol);
gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView), polyCountCol);
gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView), modelCountCol);
gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView), skinCountCol);
gtk_box_pack_start(GTK_BOX(_widget), gtkutil::ScrolledFrame(_treeView), TRUE, TRUE, 0);
// Populate the liststore with the entity count information
for (map::ModelBreakdown::Map::const_iterator i = _modelBreakdown.begin();
i != _modelBreakdown.end();
++i)
{
GtkTreeIter iter;
gtk_list_store_append(_listStore, &iter);
gtk_list_store_set(_listStore, &iter,
MODEL_COL, i->first.c_str(),
POLYCOUNT_COL, i->second.polyCount,
MODELCOUNT_COL, i->second.count,
SKINCOUNT_COL, i->second.skinCount.size(),
-1);
}
// The table containing the primitive statistics
GtkTable* table = GTK_TABLE(gtk_table_new(2, 2, FALSE));
gtk_box_pack_start(GTK_BOX(_widget), GTK_WIDGET(table), FALSE, FALSE, 0);
_modelCount = gtkutil::LeftAlignedLabel("");
_skinCount = gtkutil::LeftAlignedLabel("");
GtkWidget* modelsLabel = gtkutil::LeftAlignedLabel(_("Models used:"));
GtkWidget* skinsLabel = gtkutil::LeftAlignedLabel(_("Named Skins used:"));
gtk_widget_set_size_request(modelsLabel, 120, -1);
gtk_widget_set_size_request(skinsLabel, 120, -1);
gtk_table_attach(table, modelsLabel, 0, 1, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_table_attach(table, skinsLabel, 0, 1, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
std::string mc = "<b>" + sizetToStr(_modelBreakdown.getMap().size()) + "</b>";
std::string sc = "<b>" + sizetToStr(_modelBreakdown.getNumSkins()) + "</b>";
gtk_label_set_markup(GTK_LABEL(_modelCount), mc.c_str());
gtk_label_set_markup(GTK_LABEL(_skinCount), sc.c_str());
gtk_table_attach_defaults(table, _modelCount, 1, 2, 0, 1);
gtk_table_attach_defaults(table, _skinCount, 1, 2, 1, 2);
}
static void
gimp_controller_list_init (GimpControllerList *list)
{
GtkWidget *hbox;
GtkWidget *sw;
GtkWidget *tv;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *vbox;
GtkWidget *image;
GtkIconSize icon_size;
gint icon_width;
gint icon_height;
GType *controller_types;
guint n_controller_types;
gint i;
gtk_orientable_set_orientation (GTK_ORIENTABLE (list),
GTK_ORIENTATION_VERTICAL);
list->gimp = NULL;
list->hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (list), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0);
gtk_widget_show (sw);
list->src = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_GTYPE);
tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list->src));
g_object_unref (list->src);
gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (tv), FALSE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Available Controllers"));
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"icon-name", COLUMN_ICON,
NULL);
g_object_get (cell, "stock-size", &icon_size, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", COLUMN_NAME,
NULL);
gtk_container_add (GTK_CONTAINER (sw), tv);
gtk_widget_show (tv);
g_signal_connect_object (tv, "row-activated",
G_CALLBACK (gimp_controller_list_row_activated),
G_OBJECT (list), 0);
list->src_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv));
gtk_tree_selection_set_mode (list->src_sel, GTK_SELECTION_BROWSE);
g_signal_connect_object (list->src_sel, "changed",
G_CALLBACK (gimp_controller_list_src_sel_changed),
G_OBJECT (list), 0);
controller_types = g_type_children (GIMP_TYPE_CONTROLLER,
&n_controller_types);
for (i = 0; i < n_controller_types; i++)
{
GimpControllerClass *controller_class;
GtkTreeIter iter;
controller_class = g_type_class_ref (controller_types[i]);
gtk_list_store_append (list->src, &iter);
gtk_list_store_set (list->src, &iter,
COLUMN_ICON, controller_class->icon_name,
COLUMN_NAME, controller_class->name,
COLUMN_TYPE, controller_types[i],
-1);
g_type_class_unref (controller_class);
}
g_free (controller_types);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
list->add_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (vbox), list->add_button, TRUE, FALSE, 0);
gtk_widget_set_sensitive (list->add_button, FALSE);
gtk_widget_show (list->add_button);
image = gtk_image_new_from_icon_name ("go-next",
GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (list->add_button), image);
gtk_widget_show (image);
g_signal_connect (list->add_button, "clicked",
G_CALLBACK (gimp_controller_list_add_clicked),
list);
g_object_add_weak_pointer (G_OBJECT (list->add_button),
(gpointer) &list->add_button);
list->remove_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (vbox), list->remove_button, TRUE, FALSE, 0);
gtk_widget_set_sensitive (list->remove_button, FALSE);
gtk_widget_show (list->remove_button);
image = gtk_image_new_from_icon_name ("go-previous",
GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (list->remove_button), image);
gtk_widget_show (image);
g_signal_connect (list->remove_button, "clicked",
G_CALLBACK (gimp_controller_list_remove_clicked),
list);
g_object_add_weak_pointer (G_OBJECT (list->remove_button),
(gpointer) &list->remove_button);
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (list)),
icon_size, &icon_width, &icon_height);
list->dest = gimp_container_tree_view_new (NULL, NULL, icon_height, 0);
gimp_container_tree_view_set_main_column_title (GIMP_CONTAINER_TREE_VIEW (list->dest),
_("Active Controllers"));
gtk_tree_view_set_headers_visible (GIMP_CONTAINER_TREE_VIEW (list->dest)->view,
TRUE);
gtk_box_pack_start (GTK_BOX (list->hbox), list->dest, TRUE, TRUE, 0);
gtk_widget_show (list->dest);
g_signal_connect_object (list->dest, "select-item",
G_CALLBACK (gimp_controller_list_select_item),
G_OBJECT (list), 0);
g_signal_connect_object (list->dest, "activate-item",
G_CALLBACK (gimp_controller_list_activate_item),
G_OBJECT (list), 0);
list->edit_button =
gimp_editor_add_button (GIMP_EDITOR (list->dest),
"document-properties",
_("Configure the selected controller"),
NULL,
G_CALLBACK (gimp_controller_list_edit_clicked),
NULL,
list);
list->up_button =
gimp_editor_add_button (GIMP_EDITOR (list->dest),
"go-up",
_("Move the selected controller up"),
NULL,
G_CALLBACK (gimp_controller_list_up_clicked),
NULL,
list);
list->down_button =
gimp_editor_add_button (GIMP_EDITOR (list->dest),
"go-down",
_("Move the selected controller down"),
NULL,
G_CALLBACK (gimp_controller_list_down_clicked),
NULL,
list);
gtk_widget_set_sensitive (list->edit_button, FALSE);
gtk_widget_set_sensitive (list->up_button, FALSE);
gtk_widget_set_sensitive (list->down_button, FALSE);
}
/* 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;
}
static ddb_gtkui_widget_t *
w_pltbrowser_create (void) {
w_pltbrowser_t *w = malloc (sizeof (w_pltbrowser_t));
memset (w, 0, sizeof (w_pltbrowser_t));
w->base.widget = gtk_event_box_new ();
w->base.init = w_pltbrowser_init;
w->base.message = pltbrowser_message;
w->base.initmenu = w_pltbrowser_initmenu;
gtk_widget_set_can_focus (w->base.widget, FALSE);
GtkWidget *scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_can_focus (scroll, FALSE);
gtk_widget_show (scroll);
gtk_container_add (GTK_CONTAINER (w->base.widget), scroll);
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_ETCHED_IN);
w->tree = gtk_tree_view_new ();
gtk_tree_view_set_reorderable (GTK_TREE_VIEW (w->tree), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (w->tree), TRUE);
GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (w->tree));
gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE);
gtk_widget_show (w->tree);
gtk_container_add (GTK_CONTAINER (scroll), w->tree);
GtkListStore *store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (GTK_TREE_VIEW (w->tree), GTK_TREE_MODEL (store));
w->ri_id = g_signal_connect ((gpointer) store, "row_inserted", G_CALLBACK (on_pltbrowser_row_inserted), w);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (w->tree), TRUE);
GtkCellRenderer *rend1 = gtk_cell_renderer_text_new ();
GtkCellRenderer *rend2 = gtk_cell_renderer_text_new ();
GtkTreeViewColumn *col1 = gtk_tree_view_column_new_with_attributes (_("Name"), rend1, "text", 0, NULL);
GtkTreeViewColumn *col2 = gtk_tree_view_column_new_with_attributes (_("Items"), rend2, "text", 1, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (w->tree), col1);
gtk_tree_view_append_column (GTK_TREE_VIEW (w->tree), col2);
gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (w->tree), TRUE);
int showheaders = deadbeef->conf_get_int ("gtkui.pltbrowser.show_headers", 1);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (w->tree), showheaders);
gtk_cell_renderer_set_alignment (GTK_CELL_RENDERER (rend2), 1.0, 0.0);
w->cc_id = g_signal_connect ((gpointer) w->tree, "cursor_changed",
G_CALLBACK (on_pltbrowser_cursor_changed),
w);
g_signal_connect ((gpointer) w->tree, "event_after",
G_CALLBACK (on_pltbrowser_button_press_event),
w);
g_signal_connect ((gpointer) w->tree, "row_activated",
G_CALLBACK (on_pltbrowser_row_activated),
w);
gtkui_plugin->w_override_signals (w->base.widget, w);
return (ddb_gtkui_widget_t *)w;
}
/* 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;
}
void stk_create_userlist(GtkWidget *window)
{
GtkWidget *notebook;
GtkWidget *label;
GtkWidget *sw_buddy, *sw_group;
GtkWidget *tree;
GtkListStore *store;
GtkTreeSelection *select_item;
stk_client *client;
stk_group *group;
int num;
notebook = gtk_notebook_new();
gtk_container_set_border_width(GTK_CONTAINER (notebook), 6);
gtk_container_add(GTK_CONTAINER(window), notebook);
/* buddy list treeview */
sw_buddy = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw_buddy), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw_buddy), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
store = gtk_list_store_new(STK_BUDDY_COL_NUM, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
select_item = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select_item, GTK_SELECTION_SINGLE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(tree), TRUE);
//gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_hover_expand(GTK_TREE_VIEW(tree), TRUE);
stk_buddytree_setup(tree);
gtk_container_add(GTK_CONTAINER (sw_buddy), tree);
num = stk_get_usernum();
client = NULL;
while (num--) {
client = stk_next_user(client);
stk_buddytree_fill(tree, client);
}
/* this is for update buddytree usage - important. */
treeview = tree;
/* group list treeview */
sw_group = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw_group), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw_group), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
store = gtk_list_store_new(STK_GROUP_COL_NUM, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), TRUE);
select_item = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select_item, GTK_SELECTION_SINGLE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(tree), TRUE);
//gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(tree), TRUE);
gtk_tree_view_set_hover_expand(GTK_TREE_VIEW(tree), TRUE);
stk_grouptree_setup(tree);
gtk_container_add(GTK_CONTAINER (sw_group), tree);
num = stk_get_groupnum();
group = NULL;
while (num--) {
group = stk_next_group(group);
stk_grouptree_fill(tree, group);
}
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sw_buddy, gtk_label_new ("User List"));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sw_group, gtk_label_new ("Group List"));
}
static void
account_categories_tree_view_prepare (hierarchy_data *data)
{
GSList *list;
gchar *gnc_accounts_dir;
gchar *locale_dir;
GtkTreeView *tree_view;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreePath *path;
gnc_accounts_dir = gnc_path_get_accountsdir ();
locale_dir = gnc_get_ea_locale_dir (gnc_accounts_dir);
list = gnc_load_example_account_list (locale_dir);
g_free (gnc_accounts_dir);
g_free (locale_dir);
/* Prepare the account_categories GtkTreeView with a model and with some columns */
tree_view = data->categories_tree;
model = gtk_list_store_new(NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER);
gtk_tree_view_set_model (tree_view, GTK_TREE_MODEL(model));
g_object_unref (model);
g_slist_foreach(list, (GFunc)add_one_category, data);
g_signal_connect (G_OBJECT (model), "row_changed",
G_CALLBACK (categories_selection_changed),
data);
renderer = gtk_cell_renderer_toggle_new ();
g_object_set (G_OBJECT (renderer), "activatable", TRUE, NULL);
column = gtk_tree_view_column_new_with_attributes (_("Selected"),
renderer,
"active", COL_CHECKED,
NULL);
gtk_tree_view_append_column (tree_view, column);
gtk_tree_view_column_set_sort_column_id (column, COL_CHECKED);
g_signal_connect (G_OBJECT (renderer), "toggled",
G_CALLBACK (category_checkbox_toggled),
model);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Account Types"),
renderer,
"text", COL_TITLE,
NULL);
gtk_tree_view_append_column (tree_view, column);
gtk_tree_view_column_set_sort_column_id (column, COL_TITLE);
// renderer = gtk_cell_renderer_text_new ();
// column = gtk_tree_view_column_new_with_attributes (_("Description"),
// renderer,
// "text", COL_SHORT_DESCRIPTION,
// NULL);
// gtk_tree_view_append_column (tree_view, column);
// gtk_tree_view_column_set_sort_column_id (column, COL_SHORT_DESCRIPTION);
gtk_tree_view_set_headers_clickable(tree_view, TRUE);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE(model),
COL_TITLE,
GTK_SORT_ASCENDING);
if (data->initial_category)
{
path = gtk_tree_row_reference_get_path(data->initial_category);
selection = gtk_tree_view_get_selection(tree_view);
gtk_tree_view_scroll_to_cell(tree_view, path, NULL, TRUE, 0.5, 0.5);
gtk_tree_selection_select_path(selection, path);
gtk_tree_path_free(path);
}
}
void
fi_gui_init(void)
{
fi_sources = g_hash_table_new(NULL, NULL);
{
GtkTreeViewColumn *column;
GtkTreeView *tv;
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_aliases"));
treeview_download_aliases = tv;
store_aliases = gtk_list_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_aliases));
column = gtk_tree_view_column_new_with_attributes(_("Aliases"),
create_text_cell_renderer(0.0),
"text", 0,
(void *) 0);
configure_column(column);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_append_column(tv, column);
tree_view_set_fixed_height_mode(tv, TRUE);
drag_attach_text(GTK_WIDGET(tv), fi_gui_get_alias);
}
{
static const struct {
enum c_src id;
const char *title;
} tab[] = {
{ c_src_host, N_("Host"), },
{ c_src_country, N_("Country"), },
{ c_src_server, N_("Server"), },
{ c_src_range, N_("Range"), },
{ c_src_progress, N_("Progress"), },
{ c_src_status, N_("Status"), },
};
GtkTreeView *tv;
unsigned i;
STATIC_ASSERT(c_src_num == G_N_ELEMENTS(tab));
tv = GTK_TREE_VIEW(gui_main_window_lookup("treeview_download_sources"));
treeview_download_sources = tv;
store_sources = gtk_list_store_new(1, G_TYPE_POINTER);
gtk_tree_view_set_model(tv, GTK_TREE_MODEL(store_sources));
for (i = 0; i < G_N_ELEMENTS(tab); i++) {
GtkCellRenderer *renderer;
renderer = tab[i].id == c_src_progress
? gtk_cell_renderer_progress_new()
: NULL;
add_column(tv, tab[i].id, _(tab[i].title), 0.0,
renderer, render_sources);
}
gtk_tree_view_set_headers_clickable(tv, FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(tv),
GTK_SELECTION_MULTIPLE);
tree_view_restore_widths(tv, PROP_SOURCES_COL_WIDTHS);
tree_view_set_fixed_height_mode(tv, TRUE);
widget_add_popup_menu(GTK_WIDGET(tv), fi_gui_sources_get_popup_menu);
}
fi_gui_details_treeview_init();
fi_gui_common_init();
}
/* 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;
}
/* For now we show all the sources from a group in a List.
Later we will us a Tree to show them usings groups. */
static void
eds_load_resources (ESourceGroup *group,
PlannerPlugin *plugin,
const gchar *search)
{
GtkListStore *model;
GSList *sources, *sl;
PlannerPluginPriv *priv;
g_return_if_fail (E_IS_SOURCE_GROUP (group));
sources = e_source_group_peek_sources (group);
priv = plugin->priv;
model = GTK_LIST_STORE (priv->resources_model);
if (sources == NULL) {
if (model) {
gtk_list_store_clear (model);
}
gtk_widget_set_sensitive (glade_xml_get_widget (priv->glade,
"search_box"), FALSE);
return;
}
if (model) {
gtk_list_store_clear (model);
} else {
GtkCellRenderer *toggle;
guint column_pos;
GtkTreeViewColumn *column;
model = gtk_list_store_new (NUM_RESOURCE_COLS,
G_TYPE_STRING, /* name */
G_TYPE_STRING, /* email */
G_TYPE_BOOLEAN, /* import */
GDK_TYPE_PIXBUF, /* photo */
G_TYPE_OBJECT); /* full contact */
priv->resources_model = GTK_TREE_MODEL (model);
gtk_tree_view_set_model (priv->resources_tree_view,
priv->resources_model);
/* Name Column with sorting features */
column_pos = gtk_tree_view_insert_column_with_attributes
(priv->resources_tree_view,
-1, _("Name"),
gtk_cell_renderer_text_new (), "text", COL_RESOURCE_NAME,
NULL);
column = gtk_tree_view_get_column (priv->resources_tree_view, column_pos-1);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (priv->resources_model),
column_pos-1,
eds_compare_field,
GINT_TO_POINTER (column_pos-1),
NULL);
gtk_tree_view_column_set_sort_column_id (column, column_pos-1);
g_signal_connect (gtk_tree_view_get_column
(priv->resources_tree_view, column_pos-1),
"clicked",
G_CALLBACK (eds_column_clicked),
plugin);
/* Email column with sorting features */
column_pos = gtk_tree_view_insert_column_with_attributes
(priv->resources_tree_view,
-1, _("Email"),
gtk_cell_renderer_text_new (), "text", COL_RESOURCE_EMAIL,
NULL);
column = gtk_tree_view_get_column (priv->resources_tree_view, column_pos-1);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (priv->resources_model),
column_pos-1,
eds_compare_field,
GINT_TO_POINTER (column_pos-1),
NULL);
gtk_tree_view_column_set_sort_column_id (column, column_pos-1);
g_signal_connect (gtk_tree_view_get_column
(priv->resources_tree_view, column_pos-1),
"clicked",
G_CALLBACK (eds_column_clicked),
plugin);
/* Import */
toggle = gtk_cell_renderer_toggle_new ();
gtk_tree_view_insert_column_with_attributes
(priv->resources_tree_view,
-1, _("Import"),
toggle, "active", COL_RESOURCE_SELECTED,
NULL);
g_signal_connect (toggle, "toggled",
G_CALLBACK (eds_resource_selected),
plugin);
/* Photo */
gtk_tree_view_insert_column_with_attributes
(priv->resources_tree_view,
-1, _("Photo"),
gtk_cell_renderer_pixbuf_new (), "pixbuf", COL_RESOURCE_PHOTO,
NULL);
gtk_tree_view_set_headers_clickable (priv->resources_tree_view, TRUE);
}
for (sl = sources; sl; sl = sl->next) {
EBook *client;
AsyncQuery *async_query = g_new0 (AsyncQuery, 1);
g_free (plugin->priv->current_query_id);
plugin->priv->current_query_id = e_uid_new ();
async_query->plugin = plugin;
async_query->uid = plugin->priv->current_query_id;
async_query->search = search;
client = e_book_new (sl->data, NULL);
g_message ("Open book async query: %s", async_query->uid);
e_book_async_open (client, TRUE, eds_receive_book_cb, async_query);
eds_plugin_busy (plugin, TRUE);
}
}
void ctree_init(void)
{
GtkTreeView *view = GTK_TREE_VIEW(ctree_wnd);
GtkTreeModel *model;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
gint i;
tree = gtk_tree_store_new(CTREE_NCOLS, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_POINTER,
G_TYPE_STRING, GDK_TYPE_PIXBUF);
model = GTK_TREE_MODEL(tree);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
column = gtk_tree_view_column_new();
gtk_tree_view_append_column(view, column);
gtk_tree_view_column_set_title(column, _("Name"));
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer, "pixbuf",
COLUMN_ICON, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
renderer, FALSE);
gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
renderer, "text", COLUMN_NAME,
"font", COLUMN_FONT,
NULL);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Attr"),
renderer, "pixbuf",
COLUMN_ATTR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"),
renderer, "text",
COLUMN_TYPE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"),
renderer, "text",
COLUMN_SIZE, NULL);
for (i = 0; i < CTREE_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(tree_selection_changed), NULL);
ctree_set_basetree();
}
static void _lib_modulelist_populate_callback(gpointer instance, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
if(!self || !(self->data)) return;
GtkListStore *store;
GtkTreeIter iter;
GtkWidget *view = GTK_WIDGET(((dt_lib_modulelist_t *)self->data)->tree);
GtkCellRenderer *pix_renderer, *fav_renderer, *text_renderer;
GdkRGBA color;
GtkStyleContext *context = gtk_widget_get_style_context(view);
gboolean color_found = gtk_style_context_lookup_color (context, "selected_bg_color", &color);
if(!color_found)
{
color.red = 1.0;
color.green = 0.0;
color.blue = 0.0;
color.alpha = 1.0;
}
store = gtk_list_store_new(NUM_COLS, GDK_TYPE_PIXBUF, G_TYPE_POINTER);
gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));
g_object_unref(store);
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(store), COL_MODULE, _lib_modulelist_gui_sort, NULL, NULL);
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), COL_MODULE, GTK_SORT_ASCENDING);
pix_renderer = gtk_cell_renderer_pixbuf_new();
g_object_set(pix_renderer, "cell-background-rgba", &color, NULL);
fav_renderer = gtk_cell_renderer_pixbuf_new();
cairo_surface_t *fav_cst = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, ICON_SIZE, ICON_SIZE);
cairo_t *fav_cr = cairo_create(fav_cst);
cairo_set_source_rgb(fav_cr, 0.7, 0.7, 0.7);
dtgtk_cairo_paint_modulegroup_favorites(fav_cr, 0, 0, ICON_SIZE, ICON_SIZE, 0);
guchar *data = cairo_image_surface_get_data(fav_cst);
dt_draw_cairo_to_gdk_pixbuf(data, ICON_SIZE, ICON_SIZE);
((dt_lib_modulelist_t *)self->data)->fav_pixbuf
= gdk_pixbuf_new_from_data(data, GDK_COLORSPACE_RGB, TRUE, 8, ICON_SIZE, ICON_SIZE,
cairo_image_surface_get_stride(fav_cst), NULL, NULL);
g_object_set(fav_renderer, "cell-background-rgba", &color, NULL);
g_object_set(fav_renderer, "width", gdk_pixbuf_get_width(((dt_lib_modulelist_t *)self->data)->fav_pixbuf),
NULL);
text_renderer = gtk_cell_renderer_text_new();
g_object_set(text_renderer, "cell-background-rgba", &color, NULL);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(view), FALSE);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE);
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 0);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 0, "favorite", fav_renderer,
favorite_renderer_function, NULL, NULL);
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 1);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 1, "image", pix_renderer,
image_renderer_function, NULL, NULL);
col = gtk_tree_view_get_column(GTK_TREE_VIEW(view), 2);
if(col) gtk_tree_view_remove_column(GTK_TREE_VIEW(view), col);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(view), 2, "name", text_renderer,
text_renderer_function, NULL, NULL);
/* go thru list of iop modules and add them to the list */
GList *modules = g_list_last(darktable.develop->iop);
char datadir[PATH_MAX] = { 0 };
dt_loc_get_datadir(datadir, sizeof(datadir));
while(modules)
{
dt_iop_module_t *module = (dt_iop_module_t *)(modules->data);
if(!dt_iop_is_hidden(module) && !(module->flags() & IOP_FLAGS_DEPRECATED) && module->multi_priority == 0)
{
GdkPixbuf *pixbuf;
char filename[PATH_MAX] = { 0 };
snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/%s.svg", datadir, module->op);
pixbuf = load_image(filename);
if(pixbuf) goto end;
snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/%s.png", datadir, module->op);
pixbuf = load_image(filename);
if(pixbuf) goto end;
snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/template.svg", datadir);
pixbuf = load_image(filename);
if(pixbuf) goto end;
snprintf(filename, sizeof(filename), "%s/pixmaps/plugins/darkroom/template.png", datadir);
pixbuf = load_image(filename);
if(pixbuf) goto end;
// wow, we could neither load the SVG nor the PNG files. something is f****d up.
pixbuf = gdk_pixbuf_new_from_data(fallback_pixel, GDK_COLORSPACE_RGB, TRUE, 8, 1, 1, 4, NULL, NULL);
end:
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, COL_IMAGE, pixbuf, COL_MODULE, module, -1);
g_object_unref(pixbuf);
}
modules = g_list_previous(modules);
}
}
CMatchingDlg::CMatchingDlg(GtkWindow *pParent):m_pParent(pParent), m_FileList(NULL), m_FrameCols(NULL),
m_CatalogCols(NULL), m_ChartData(NULL), m_ImageData(NULL), m_CatFile(NULL), m_SelectionName(NULL),
m_Updating(false)
{
int i, w, width, mon;
GtkWidget *tbox, *tbar, *frame, *hbox;
GdkRectangle rc;
GSList *group;
m_Negative = CConfig::GetBool(CConfig::NEGATIVE_CHARTS);
m_RowsUpward = CConfig::GetBool(CConfig::ROWS_UPWARD);
// Dialog with buttons
m_pDlg = gtk_dialog_new_with_buttons("Match stars", pParent,
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT),
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg));
gtk_dialog_set_tooltip_by_response(GTK_DIALOG(m_pDlg), GTK_RESPONSE_ACCEPT, "Start the process");
g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);
// Dialog icon
gchar *icon = get_icon_file("matchstars");
gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
g_free(icon);
// Dialog layout
GtkWidget *vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 8);
// Dialog size
GdkScreen *scr = gtk_window_get_screen(pParent);
mon = gdk_screen_get_monitor_at_window(scr, GTK_WIDGET(pParent)->window);
gdk_screen_get_monitor_geometry(scr, mon, &rc);
if (rc.width>0 && rc.height>0)
gtk_window_set_default_size(GTK_WINDOW(m_pDlg), RoundToInt(0.7*rc.width), RoundToInt(0.7*rc.height));
// Initial state
m_SelectMode = (tSelectMode)g_Project->GetInt("MatchingDlg", "Select", REFERENCE_FRAME);
m_DMFrame = (tDisplayMode)g_Project->GetInt("MatchingDlg", "Display", DISPLAY_CHART);
m_DMCatalog = (tDisplayMode)g_Project->GetInt("MatchingDlg", "Display2", DISPLAY_CHART);
m_FrameSort = g_Project->GetInt("MatchingDlg", "Sort", FCOL_STARS);
// List of frames
m_Frames = gtk_list_store_new(FNCOLS, G_TYPE_INT, G_TYPE_INT, G_TYPE_DOUBLE, G_TYPE_INT);
// List of catalog files
m_Catalogs = gtk_list_store_new(CNCOLS, G_TYPE_STRING, G_TYPE_STRING);
// Reference frame or catalog file?
m_UseFrame = gtk_vbox_new(TRUE, 4);
gtk_box_pack_start(GTK_BOX(vbox), m_UseFrame, FALSE, TRUE, 0);
GtkWidget *label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), "<b>As a reference file, use:</b>");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(m_UseFrame), label, FALSE, TRUE, 0);
m_FrameBtn = gtk_radio_button_new_with_label(NULL, "a frame from the current project");
gtk_widget_set_tooltip_text(m_FrameBtn, "Use one of the source frames as a reference frame");
g_signal_connect(G_OBJECT(m_FrameBtn), "toggled", G_CALLBACK(button_clicked), this);
gtk_box_pack_start(GTK_BOX(m_UseFrame), m_FrameBtn, TRUE, TRUE, 0);
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(m_FrameBtn));
m_CatalogBtn = gtk_radio_button_new_with_label(group, "a catalog file from the disk");
gtk_widget_set_tooltip_text(m_CatalogBtn, "Use a catalog file as a reference frame");
g_signal_connect(G_OBJECT(m_CatalogBtn), "toggled", G_CALLBACK(button_clicked), this);
gtk_box_pack_start(GTK_BOX(m_UseFrame), m_CatalogBtn, TRUE, TRUE, 0);
// Separator
gtk_box_pack_start(GTK_BOX(m_UseFrame), gtk_label_new(NULL), FALSE, TRUE, 0);
m_SelLabel = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(m_SelLabel), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), m_SelLabel, FALSE, TRUE, 0);
tbox = gtk_table_new(2, 3, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(tbox), 0);
gtk_table_set_col_spacing(GTK_TABLE(tbox), 1, 8);
gtk_table_set_row_spacings(GTK_TABLE(tbox), 0);
gtk_table_set_row_spacing(GTK_TABLE(tbox), 1, 8);
gtk_box_pack_start(GTK_BOX(vbox), tbox, TRUE, TRUE, 0);
// List of reference frames
m_FrameView = gtk_tree_view_new();
width = 8;
for (i=0; FrameColumns[i].caption!=NULL; i++) {
GtkTreeViewColumn *col = gtk_tree_view_column_new();
// Set column name and alignment
gtk_tree_view_column_set_title(col, FrameColumns[i].caption);
gtk_tree_view_append_column(GTK_TREE_VIEW(m_FrameView), col);
// Add text renderer
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
g_object_set(renderer, "xalign", FrameColumns[i].align, NULL);
if (FrameColumns[i].datafn)
gtk_tree_view_column_set_cell_data_func(col, renderer, FrameColumns[i].datafn, NULL, NULL);
else
gtk_tree_view_column_add_attribute(col, renderer, "text", FrameColumns[i].column);
g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(frame_column_clicked), this);
tColData *data = (tColData*)g_malloc(sizeof(tColData));
data->col = col;
data->data = &FrameColumns[i];
m_FrameCols = g_slist_append(m_FrameCols, data);
if (FrameColumns[i].maxtext)
w = text_width(m_FrameView, FrameColumns[i].maxtext);
else
w = text_width(m_FrameView, FrameColumns[i].caption);
width += w + 24;
}
gtk_tree_view_set_model(GTK_TREE_VIEW(m_FrameView), GTK_TREE_MODEL(m_Frames));
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(m_FrameView), true);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(m_FrameView)), GTK_SELECTION_SINGLE);
m_FrameBox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_FrameBox),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(m_FrameBox),
GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(m_FrameBox), m_FrameView);
gtk_widget_set_size_request(m_FrameView, width, -1);
gtk_table_attach(GTK_TABLE(tbox), m_FrameBox, 0, 1, 0, 2, GTK_FILL, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), 0, 0);
// Register callback for selection change
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_FrameView));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed), this);
// Catalog files
m_CatalogView = gtk_tree_view_new();
for (i=0; CatalogColumns[i].caption!=NULL; i++) {
GtkTreeViewColumn *col = gtk_tree_view_column_new();
// Set column name and alignment
gtk_tree_view_column_set_title(col, CatalogColumns[i].caption);
gtk_tree_view_append_column(GTK_TREE_VIEW(m_CatalogView), col);
// Add text renderer
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, TRUE);
g_object_set(renderer, "xalign", CatalogColumns[i].align, NULL);
if (CatalogColumns[i].datafn)
gtk_tree_view_column_set_cell_data_func(col, renderer, CatalogColumns[i].datafn, NULL, NULL);
else
gtk_tree_view_column_add_attribute(col, renderer, "text", CatalogColumns[i].column);
tColData *data = (tColData*)g_malloc(sizeof(tColData));
data->col = col;
data->data = &CatalogColumns[i];
m_CatalogCols = g_slist_append(m_CatalogCols, data);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(m_CatalogView), GTK_TREE_MODEL(m_Catalogs));
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(m_CatalogView), true);
m_CatalogBox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(m_CatalogBox),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(m_CatalogBox),
GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(m_CatalogBox), m_CatalogView);
gtk_widget_set_size_request(m_CatalogView, width, -1);
gtk_table_attach(GTK_TABLE(tbox), m_CatalogBox, 1, 2, 0, 2, GTK_FILL, (GtkAttachOptions)(GTK_FILL | GTK_EXPAND), 0, 0);
// Register callback for selection change
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_CatalogView));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed), this);
// Toolbox
tbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_TEXT);
m_ShowChart = toolbar_new_radio_button(tbar, NULL, "Chart", "Display objects on a flat background");
g_signal_connect(G_OBJECT(m_ShowChart), "toggled", G_CALLBACK(button_clicked), this);
m_ShowImage = toolbar_new_radio_button(tbar, m_ShowChart, "Image", "Display an image only");
g_signal_connect(G_OBJECT(m_ShowImage), "toggled", G_CALLBACK(button_clicked), this);
gtk_table_attach(GTK_TABLE(tbox), tbar, 2, 3, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL), GTK_FILL, 0, 0);
// Frame preview
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
m_Preview = cmpack_chart_view_new();
gtk_container_add(GTK_CONTAINER(frame), m_Preview);
gtk_widget_set_size_request(frame, 160, 120);
gtk_table_attach_defaults(GTK_TABLE(tbox), frame, 2, 3, 1, 2);
// Bottom toolbox
hbox = gtk_hbox_new(FALSE, 8);
m_OptionsBtn = gtk_button_new_with_label("Options");
gtk_widget_set_tooltip_text(m_OptionsBtn, "Edit project settings");
gtk_box_pack_start(GTK_BOX(hbox), m_OptionsBtn, 0, 0, 0);
g_signal_connect(G_OBJECT(m_OptionsBtn), "clicked", G_CALLBACK(button_clicked), this);
m_PathLabel = gtk_label_new("Search path:");
gtk_box_pack_start(GTK_BOX(hbox), m_PathLabel, FALSE, TRUE, 0);
m_PathEntry = gtk_entry_new();
gtk_widget_set_tooltip_text(m_PathEntry, "Path to the folder with catalog files");
gtk_editable_set_editable(GTK_EDITABLE(m_PathEntry), false);
gtk_box_pack_start(GTK_BOX(hbox), m_PathEntry, TRUE, TRUE, 0);
m_PathBtn = gtk_button_new_with_label("Change folder");
gtk_widget_set_tooltip_text(m_PathBtn, "Change folder with catalog files");
g_signal_connect(G_OBJECT(m_PathBtn), "clicked", G_CALLBACK(button_clicked), this);
gtk_box_pack_start(GTK_BOX(hbox), m_PathBtn, FALSE, TRUE, 0);
gtk_table_attach(GTK_TABLE(tbox), hbox, 0, 3, 2, 3, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox);
}
void clist_init(void)
{
GtkTreeView *view = GTK_TREE_VIEW(clist_wnd);
GtkTreeModel *model = GTK_TREE_MODEL(list);
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
gint i;
list = gtk_list_store_new(CLIST_NCOLS, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_POINTER
);
model = GTK_TREE_MODEL(list);
gtk_tree_view_set_model(view, model);
gtk_tree_view_set_headers_visible(view, TRUE);
gtk_tree_view_set_headers_clickable(view, TRUE);
gtk_tree_view_set_rules_hint(view, FALSE);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(view, -1, "",
renderer, "pixbuf",
COLUMN_ICON, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Name"),
renderer, "text",
COLUMN_NAME, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Type"),
renderer, "text",
COLUMN_TYPE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Size"),
renderer, "text",
COLUMN_SIZE, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(view, -1, _("Date"),
renderer, "text",
COLUMN_DATE, NULL);
for (i = 0; i < CLIST_NVCOLS; i++)
{
GtkTreeViewColumn *col;
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_set_clickable(col, TRUE);
g_signal_connect(G_OBJECT(col), "clicked", G_CALLBACK(column_clicked), view);
}
selection = gtk_tree_view_get_selection(view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
gtk_tree_selection_set_select_function(selection, select_func, NULL, NULL);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(tree_selection_changed), NULL);
}
PrefabSelector::PrefabSelector () :
_widget(gtk_vbox_new(FALSE, 2)), _store(gtk_tree_store_new(PREFAB_STORE_SIZE, G_TYPE_STRING, G_TYPE_STRING,
GDK_TYPE_PIXBUF, G_TYPE_STRING)),
_fileFiltered(gtk_tree_model_filter_new(GTK_TREE_MODEL(_store), NULL)), _fileSorted(
GTK_TREE_MODEL(gtk_tree_model_sort_new_with_model(_fileFiltered))), _view(
GTK_TREE_VIEW(gtk_tree_view_new_with_model(_fileSorted)))
{
std::string fullpath = GlobalRegistry().get(RKEY_APP_PATH) + "prefabs/";
_selectedSelectionStrategy = PREFAB_SELECT_EXTEND;
GtkWidget* scr = gtk_scrolled_window_new(0, 0);
gtk_box_pack_start(GTK_BOX(_widget), scr, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scr), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scr), GTK_SHADOW_IN);
{
gtk_tree_view_set_enable_search(_view, TRUE);
gtk_tree_view_set_search_column(_view, PREFAB_SHORTNAME);
gtk_tree_view_set_headers_visible(_view, TRUE);
gtk_tree_view_set_headers_clickable(_view, TRUE);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_grid_lines(_view, GTK_TREE_VIEW_GRID_LINES_HORIZONTAL);
#endif
g_signal_connect(G_OBJECT(_view), "button_press_event", G_CALLBACK(callbackButtonPress), this);
{
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Prefab"));
gtk_tree_view_column_set_expand(column, FALSE);
gtk_tree_view_column_set_sort_indicator(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, PREFAB_SHORTNAME);
gtk_tree_view_append_column(_view, column);
GtkCellRenderer* imageRenderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_renderer_set_fixed_size(imageRenderer, 128, -1);
gtk_tree_view_column_pack_start(column, imageRenderer, false);
gtk_tree_view_column_add_attribute(column, imageRenderer, "pixbuf", PREFAB_IMAGE);
GtkCellRenderer* nameRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_end(column, nameRenderer, false);
gtk_tree_view_column_add_attribute(column, nameRenderer, "markup", PREFAB_DESCRIPTION);
}
gtk_container_add(GTK_CONTAINER(scr), GTK_WIDGET(_view));
g_object_unref(G_OBJECT(_store));
}
GtkWidget* hboxFooter = gtk_hbox_new(TRUE, 0);
gtk_box_pack_start(GTK_BOX(_widget), hboxFooter, FALSE, TRUE, 0);
{
// options
GtkWidget* vboxOptions = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxOptions, FALSE, TRUE, 0);
GtkRadioButton* radioExtendSelection =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label(NULL, _("Extend current selection")));
gtk_widget_ref(GTK_WIDGET(radioExtendSelection));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioExtendSelection), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioExtendSelection), "handler", gint_to_pointer(
g_signal_connect(radioExtendSelection,
"toggled", G_CALLBACK(callbackSelectionOptionToggleExtend), this)));
GtkRadioButton
* radioUnselect =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioExtendSelection, _("Deselect before insert")));
gtk_widget_ref(GTK_WIDGET(radioUnselect));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioUnselect), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioUnselect), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioUnselect),
"toggled", G_CALLBACK(callbackSelectionOptionToggleUnselect), this)));
GtkRadioButton
* radioReplace =
GTK_RADIO_BUTTON(gtk_radio_button_new_with_label_from_widget(radioUnselect, _("Replace current selection")));
gtk_widget_ref(GTK_WIDGET(radioReplace));
gtk_box_pack_start(GTK_BOX(vboxOptions), GTK_WIDGET(radioReplace), TRUE, TRUE, 0);
g_object_set_data(G_OBJECT(radioReplace), "handler", gint_to_pointer(
g_signal_connect(G_OBJECT(radioReplace),
"toggled", G_CALLBACK(callbackSelectionOptionToggleReplace), this)));
}
{
//search entry, connect to file filter
GtkWidget* vboxSearch = gtk_vbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(hboxFooter), vboxSearch, FALSE, TRUE, 3);
GtkWidget *searchEntry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(vboxSearch), searchEntry, FALSE, TRUE, 3);
gtk_widget_show(searchEntry);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(_fileFiltered),
(GtkTreeModelFilterVisibleFunc) callbackFilterFiles, this, NULL);
g_signal_connect(G_OBJECT(searchEntry), "changed", G_CALLBACK(callbackRefilter), NULL);
_filterEntry = GTK_ENTRY(searchEntry);
#if GTK_CHECK_VERSION(2,10,0)
gtk_tree_view_set_search_entry(_view, _filterEntry);
#endif
}
/* fill prefab store with data */
Directory_forEach(fullpath, LoadPrefabDirectoryFunctor(fullpath, "", NULL, _store));
Directory_forEach(fullpath, MatchFileExtension<LoadPrefabFileFunctor> ("map", LoadPrefabFileFunctor("", NULL, _store)));
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(_fileFiltered));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(_fileSorted), PREFAB_SHORTNAME, GTK_SORT_ASCENDING);
}
/* 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;
}
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;
}
void
port_setup_dialog(void) {
GtkWidget * vbox;
GtkWidget * table;
GtkWidget * button_rescan;
GtkWidget * button_close;
GtkWidget * button_clear_outs;
GtkWidget * frame_dl;
GtkWidget * frame_dr;
GtkCellRenderer * renderer_out_L;
GtkCellRenderer * renderer_out_R;
GtkTreeSelection * select_out_L;
GtkTreeSelection * select_out_R;
GtkWidget * viewp_out_L;
GtkWidget * viewp_out_R;
GtkWidget * hbox_L;
GtkWidget * hbox_R;
GtkWidget * label_L;
GtkWidget * label_R;
GdkColor color = { 0, 0, 0, 0 };
store_out_L = gtk_list_store_new(1, G_TYPE_STRING);
store_out_R = gtk_list_store_new(1, G_TYPE_STRING);
ports_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(ports_window), _("JACK Port Setup"));
gtk_window_set_position(GTK_WINDOW(ports_window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(ports_window), TRUE);
gtk_window_set_transient_for(GTK_WINDOW(ports_window), GTK_WINDOW(main_window));
g_signal_connect(G_OBJECT(ports_window), "delete_event", G_CALLBACK(port_window_close), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(ports_window), vbox);
table = gtk_table_new(2, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 2);
button_rescan = gui_stock_label_button(_("Rescan"), GTK_STOCK_REFRESH);
gtk_table_attach(GTK_TABLE(table), button_rescan, 0, 1, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 5);
g_signal_connect(G_OBJECT(button_rescan), "clicked", G_CALLBACK(clicked_rescan), NULL);
button_close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_table_attach(GTK_TABLE(table), button_close, 1, 2, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 5);
g_signal_connect(G_OBJECT(button_close), "clicked", G_CALLBACK(ports_clicked_close), NULL);
frame_dl = gtk_frame_new(_("Outputs"));
gtk_table_attach(GTK_TABLE(table), frame_dl, 0, 1, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 5, 5);
frame_dr = gtk_frame_new(_("Available connections"));
gtk_table_attach(GTK_TABLE(table), frame_dr, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 5, 5);
vbox_dl = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox_dl), 8);
gtk_container_add(GTK_CONTAINER(frame_dl), vbox_dl);
vbox_dr = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox_dr), 8);
gtk_container_add(GTK_CONTAINER(frame_dr), vbox_dr);
button_clear_outs = gui_stock_label_button(_("Clear connections"), GTK_STOCK_CLEAR);
gtk_box_pack_start(GTK_BOX(vbox_dl), button_clear_outs, FALSE, TRUE, 2);
g_signal_connect(G_OBJECT(button_clear_outs), "clicked", G_CALLBACK(clear_outs), NULL);
nb_outs = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox_dr), nb_outs, TRUE, TRUE, 2);
scan_connections(out_L_port, store_out_L);
scan_connections(out_R_port, store_out_R);
tree_out_L = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store_out_L));
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree_out_L), FALSE);
tree_out_R = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store_out_R));
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree_out_R), FALSE);
renderer_out_L = gtk_cell_renderer_text_new();
renderer_out_R = gtk_cell_renderer_text_new();
column_out_L = gtk_tree_view_column_new_with_attributes(NULL, renderer_out_L, "text", 0, NULL);
column_out_R = gtk_tree_view_column_new_with_attributes(NULL, renderer_out_R, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_out_L), column_out_L);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_out_R), column_out_R);
g_signal_connect(G_OBJECT(column_out_L->button), "clicked", G_CALLBACK(clicked_out_L_header), NULL);
g_signal_connect(G_OBJECT(column_out_R->button), "clicked", G_CALLBACK(clicked_out_R_header), NULL);
gtk_widget_set_name(column_out_L->button, "nostyle");
gtk_widget_set_name(column_out_R->button, "nostyle");
select_out_L = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_out_L));
gtk_tree_selection_set_mode(select_out_L, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select_out_L), "changed", G_CALLBACK(tree_out_L_selection_changed), NULL);
select_out_R = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_out_R));
gtk_tree_selection_set_mode(select_out_R, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select_out_R), "changed", G_CALLBACK(tree_out_R_selection_changed), NULL);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tree_out_L), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tree_out_R), TRUE);
viewp_out_L = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewp_out_L), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(viewp_out_L), tree_out_L);
gtk_widget_set_size_request(GTK_WIDGET(viewp_out_L), LIST_WIDTH, LIST_HEIGHT);
viewp_out_R = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewp_out_R), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(viewp_out_R), tree_out_R);
gtk_widget_set_size_request(GTK_WIDGET(viewp_out_R), LIST_WIDTH, LIST_HEIGHT);
gtk_box_pack_start(GTK_BOX(vbox_dl), viewp_out_L, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_dl), viewp_out_R, TRUE, TRUE, 2);
setup_notebook_out();
set_active(GTK_WIDGET(column_out_L->button), TRUE);
set_active(GTK_WIDGET(column_out_R->button), FALSE);
gtk_widget_show_all(ports_window);
gtk_widget_destroy(gtk_bin_get_child(GTK_BIN(column_out_L->button)));
gtk_widget_destroy(gtk_bin_get_child(GTK_BIN(column_out_R->button)));
hbox_L = gtk_hbox_new(FALSE, 0);
hbox_R = gtk_hbox_new(FALSE, 0);
label_L = gtk_label_new(_(" out L"));
label_R = gtk_label_new(_(" out R"));
gtk_container_add(GTK_CONTAINER(column_out_L->button), hbox_L);
gtk_container_add(GTK_CONTAINER(column_out_R->button), hbox_R);
gtk_box_pack_start(GTK_BOX(hbox_L), label_L, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_R), label_R, FALSE, FALSE, 0);
gtk_widget_modify_fg(label_L, GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(label_L, GTK_STATE_PRELIGHT, &color);
gtk_widget_modify_fg(label_L, GTK_STATE_ACTIVE, &color);
gtk_widget_modify_fg(label_R, GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(label_R, GTK_STATE_PRELIGHT, &color);
gtk_widget_modify_fg(label_R, GTK_STATE_ACTIVE, &color);
gtk_widget_show_all(hbox_L);
gtk_widget_show_all(hbox_R);
}
void EntityInfoTab::populateTab() {
// Set the outer space of the vbox
gtk_container_set_border_width(GTK_CONTAINER(_widget), 12);
// Create the list store that contains the eclass => count map
_listStore = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
// Create the treeview and pack two columns into it
_treeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(_listStore));
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(_treeView), TRUE);
GtkTreeViewColumn* eclassCol = gtkutil::TextColumn(_("Entity Class"), ECLASS_COL);
gtk_tree_view_column_set_sort_column_id(eclassCol, ECLASS_COL);
GtkTreeViewColumn* countCol = gtkutil::TextColumn(_("Count"), COUNT_COL);
gtk_tree_view_column_set_sort_column_id(countCol, COUNT_COL);
gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView), eclassCol);
gtk_tree_view_append_column(GTK_TREE_VIEW(_treeView), countCol);
gtk_box_pack_start(GTK_BOX(_widget), gtkutil::ScrolledFrame(_treeView), TRUE, TRUE, 0);
// Populate the liststore with the entity count information
for (map::EntityBreakdown::Map::const_iterator i = _entityBreakdown.begin();
i != _entityBreakdown.end();
i++)
{
GtkTreeIter iter;
gtk_list_store_append(_listStore, &iter);
gtk_list_store_set(_listStore, &iter,
ECLASS_COL, i->first.c_str(),
COUNT_COL, i->second,
-1);
}
// The table containing the primitive statistics
GtkTable* table = GTK_TABLE(gtk_table_new(3, 2, FALSE));
gtk_box_pack_start(GTK_BOX(_widget), GTK_WIDGET(table), FALSE, FALSE, 0);
_brushCount = gtkutil::LeftAlignedLabel("");
_patchCount = gtkutil::LeftAlignedLabel("");
_entityCount = gtkutil::LeftAlignedLabel("");
GtkWidget* brushLabel = gtkutil::LeftAlignedLabel(_("Brushes:"));
GtkWidget* patchLabel = gtkutil::LeftAlignedLabel(_("Patches:"));
GtkWidget* entityLabel = gtkutil::LeftAlignedLabel(_("Entities:"));
gtk_widget_set_size_request(brushLabel, 75, -1);
gtk_widget_set_size_request(patchLabel, 75, -1);
gtk_widget_set_size_request(entityLabel, 75, -1);
gtk_table_attach(table, brushLabel, 0, 1, 0, 1,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_table_attach(table, patchLabel, 0, 1, 1, 2,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
gtk_table_attach(table, entityLabel, 0, 1, 2, 3,
(GtkAttachOptions) (0),
(GtkAttachOptions) (0), 0, 0);
std::string bc = "<b>" + sizetToStr(GlobalCounters().getCounter(counterBrushes).get()) + "</b>";
std::string pc = "<b>" + sizetToStr(GlobalCounters().getCounter(counterPatches).get()) + "</b>";
std::string ec = "<b>" + sizetToStr(GlobalCounters().getCounter(counterEntities).get()) + "</b>";
gtk_label_set_markup(GTK_LABEL(_brushCount), bc.c_str());
gtk_label_set_markup(GTK_LABEL(_patchCount), pc.c_str());
gtk_label_set_markup(GTK_LABEL(_entityCount), ec.c_str());
gtk_table_attach_defaults(table, _brushCount, 1, 2, 0, 1);
gtk_table_attach_defaults(table, _patchCount, 1, 2, 1, 2);
gtk_table_attach_defaults(table, _entityCount, 1, 2, 2, 3);
}
