/** * 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); }