void populate_model (QStandardItem * item,
QVector<QSize> & vec_ColsRows,
int level, QString & prevRows)
{
if ( level >= vec_ColsRows.size())
return; // não há mais níveis de hierarquia na árvore
const int totCols = vec_ColsRows[level].width();
const int totRows = vec_ColsRows[level].height();
const int row = item->rowCount();
// alimenta um nível:
QList<QStandardItem*> itCols;
for (int col = 0; col < totCols; ++ col )
itCols << new QStandardItem ( "item " + prevRows +
QString("%1%2").arg(row).arg(col));
// adiciona item neste nível:
item->appendRow(itCols );
// adiciona sub-nível neste nível:
QString newPrevRows( prevRows + QString().setNum(row) );
populate_model(item->child(row,0), vec_ColsRows, level+1, newPrevRows);
// próximo item neste nível:
if ( item->rowCount() < totRows )
populate_model(item, vec_ColsRows, level, prevRows);
}
static void
nautilus_burn_drive_selection_init (NautilusBurnDriveSelection *selection)
{
GtkCellRenderer *cell;
GtkListStore *store;
selection->priv = NAUTILUS_BURN_DRIVE_SELECTION_GET_PRIVATE (selection);
selection->priv->monitor = nautilus_burn_get_drive_monitor ();
g_signal_connect (selection->priv->monitor, "drive-connected", G_CALLBACK (drive_connected_cb), selection);
g_signal_connect (selection->priv->monitor, "drive-disconnected", G_CALLBACK (drive_disconnected_cb), selection);
store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, NAUTILUS_BURN_TYPE_DRIVE);
gtk_combo_box_set_model (GTK_COMBO_BOX (selection),
GTK_TREE_MODEL (store));
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (selection), cell, TRUE);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (selection), cell,
"text", DISPLAY_NAME_COLUMN,
NULL);
populate_model (selection, store);
selection_update_sensitivity (selection);
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (combo_changed), selection);
}
static void
activate (GApplication *app)
{
GtkBuilder *builder;
GtkWindow *window;
GtkWidget *widget;
GtkTreeModel *model;
GtkTreeIter iter;
GError *error = NULL;
static GActionEntry win_entries[] = {
{ "run", activate_run, NULL, NULL, NULL }
};
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/ui/main.ui", &error);
if (error != NULL)
{
g_critical ("%s", error->message);
exit (1);
}
window = (GtkWindow *)gtk_builder_get_object (builder, "window");
gtk_application_add_window (GTK_APPLICATION (app), window);
g_action_map_add_action_entries (G_ACTION_MAP (window),
win_entries, G_N_ELEMENTS (win_entries),
window);
notebook = (GtkWidget *)gtk_builder_get_object (builder, "notebook");
info_view = (GtkWidget *)gtk_builder_get_object (builder, "info-textview");
source_view = (GtkWidget *)gtk_builder_get_object (builder, "source-textview");
headerbar = (GtkWidget *)gtk_builder_get_object (builder, "headerbar");
treeview = (GtkWidget *)gtk_builder_get_object (builder, "treeview");
model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
load_file (gtk_demos[0].name, gtk_demos[0].filename);
populate_model (model);
g_signal_connect (treeview, "row-activated", G_CALLBACK (row_activated_cb), model);
widget = (GtkWidget *)gtk_builder_get_object (builder, "treeview-selection");
g_signal_connect (widget, "changed", G_CALLBACK (selection_cb), model);
gtk_tree_model_get_iter_first (gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)), &iter);
gtk_tree_selection_select_iter (GTK_TREE_SELECTION (widget), &iter);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (treeview));
gtk_widget_show_all (GTK_WIDGET (window));
g_object_unref (builder);
}
static void
reload_themes (void)
{
GtkWidget *treeview;
GtkTreeModel *model;
treeview = GTK_WIDGET (gtk_builder_get_object (builder, "savers_treeview"));
model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
gtk_tree_store_clear (GTK_TREE_STORE (model));
populate_model (GTK_TREE_STORE (model));
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview),
GTK_TREE_MODEL (model));
}
static void
setup_treeview (GtkWidget *tree,
GtkWidget *preview)
{
GtkTreeStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *select;
store = gtk_tree_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING);
populate_model (store);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree),
GTK_TREE_MODEL (store));
g_object_unref (store);
#if GTK_CHECK_VERSION(2,10,0)
g_object_set (tree, "show-expanders", FALSE, NULL);
#endif
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Name", renderer,
"text", NAME_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
NAME_COLUMN,
compare_theme,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
NAME_COLUMN,
GTK_SORT_ASCENDING);
gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (tree),
separator_func,
GINT_TO_POINTER (ID_COLUMN),
NULL);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed",
G_CALLBACK (tree_selection_changed_cb),
preview);
}
static void
input_chooser_repopulate (GtkListStore *active_sources_store)
{
GtkBuilder *builder;
GtkListStore *model;
if (!input_chooser)
return;
builder = g_object_get_data (G_OBJECT (input_chooser), "builder");
model = GTK_LIST_STORE (gtk_builder_get_object (builder, "input_source_model"));
gtk_list_store_clear (model);
populate_model (model, active_sources_store);
}
void todo_init()
{
todo = g_new(GtkToDo, 1);
todo->dialog = NULL;
todo->store = gtk_tree_store_new(TODO_NCOLUMNS,
G_TYPE_BOOLEAN,
G_TYPE_STRING,
G_TYPE_INT);
/* TreeView */
todo->treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(todo->store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(todo->treeview), TRUE);
add_columns(todo->treeview);
populate_model(todo->store);
}
static GtkTreeModel *
create_model (void)
{
GtkTreeStore *model;
gint i;
model = gtk_tree_store_new (NUM_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT);
for (i = 0; i < 20; i++)
populate_model (model, NULL, main_entries);
return GTK_TREE_MODEL (model);
}
/*
* A desktop file manager. This opens files and directories the same way that
* argonaut(1) does.
*/
int
main(int argc, char *argv[])
{
GtkBuilder *builder;
GtkWidget *root, *icons;
struct state *d;
char *dir;
if ((dir = get_dir()) == NULL)
err(1, "get_dir");
if ((d = state_new(BINDIR"/argonaut")) == NULL)
err(1, "could not build the callback data");
if (state_add_dir(d, dir) < 0)
err(1, "state_add_dir");
gtk_init(&argc, &argv);
builder = gtk_builder_new_from_file(INTERFACE_PATH);
icons = GTK_WIDGET(gtk_builder_get_object(builder, "desktop-icons"));
d->icon_view = GTK_ICON_VIEW(icons);
root = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(root, "argonaut-desktop");
set_window_geometry(GTK_WINDOW(root), GTK_WIDGET(icons));
desktopize(root);
skip_pager(root);
populate_model(dir, d->icon_view);
set_up_icon_view(icons, d);
gtk_container_add(GTK_CONTAINER(root), icons);
gtk_widget_show(icons);
gtk_widget_show(root);
gtk_main();
state_free(d);
free(dir);
return 0;
}
static void
repopulate_model (NautilusBurnDriveSelection *selection)
{
GtkTreeModel *model;
/* block the combo changed signal handler until we're done */
g_signal_handlers_block_by_func (G_OBJECT (selection),
combo_changed, selection);
model = gtk_combo_box_get_model (GTK_COMBO_BOX (selection));
gtk_list_store_clear (GTK_LIST_STORE (model));
populate_model (selection, GTK_LIST_STORE (model));
g_signal_handlers_unblock_by_func (G_OBJECT (selection),
combo_changed, selection);
/* Force a signal out */
combo_changed (GTK_COMBO_BOX (selection), (gpointer) selection);
}
static void
populate_model (GtkTreeStore *model,
GtkTreeIter *parent,
TreeEntry *entries)
{
GtkTreeIter iter;
gint i;
for (i = 0; entries[i].info != NULL; i++)
{
gtk_tree_store_append (model, &iter, parent);
gtk_tree_store_set (model, &iter,
ICON_COLUMN, entries[i].icon,
INFO_COLUMN, entries[i].info,
DESCRIPTION_COLUMN, entries[i].description,
FINE_PRINT_COLUMN, entries[i].fine_print,
FINE_PRINT_COLOR_COLUMN, entries[i].fine_print_color,
PROGRESS_COLUMN, entries[i].progress,
-1);
if (entries[i].entries)
populate_model (model, &iter, entries[i].entries);
}
}
static GtkWidget *
input_chooser_new (GtkWindow *main_window,
GtkListStore *active_sources)
{
GtkBuilder *builder;
GtkWidget *chooser;
GtkWidget *filtered_list;
GtkWidget *filter_entry;
GtkTreeViewColumn *visible_column;
GtkTreeSelection *selection;
GtkListStore *model;
GtkTreeModelFilter *filtered_model;
GtkTreeIter iter;
GError *error = NULL;
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder,
"/ui/gnome-region-panel-input-chooser.ui",
&error);
if (error)
g_error ("Problem parsing ui file %s", error->message);
chooser = WID ("input_source_chooser");
input_chooser = chooser;
g_object_add_weak_pointer (G_OBJECT (chooser), (gpointer *) &input_chooser);
g_object_set_data_full (G_OBJECT (chooser), "builder", builder, g_object_unref);
filtered_list = WID ("filtered_input_source_list");
filter_entry = WID ("input_source_filter");
g_object_set_data (G_OBJECT (chooser),
"filtered_input_source_list", filtered_list);
visible_column =
gtk_tree_view_column_new_with_attributes ("Input Sources",
gtk_cell_renderer_text_new (),
"text", NAME_COLUMN,
NULL);
gtk_window_set_transient_for (GTK_WINDOW (chooser), main_window);
gtk_tree_view_append_column (GTK_TREE_VIEW (filtered_list),
visible_column);
/* We handle searching ourselves, thank you. */
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (filtered_list), FALSE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (filtered_list), -1);
g_signal_connect_swapped (G_OBJECT (filter_entry), "activate",
G_CALLBACK (entry_activated), builder);
g_signal_connect_swapped (G_OBJECT (filter_entry), "notify::text",
G_CALLBACK (filter_changed), builder);
g_signal_connect (G_OBJECT (filter_entry), "icon-release",
G_CALLBACK (filter_clear), NULL);
filtered_model = GTK_TREE_MODEL_FILTER (gtk_builder_get_object (builder, "filtered_input_source_model"));
model = GTK_LIST_STORE (gtk_builder_get_object (builder, "input_source_model"));
populate_model (model, active_sources);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
NAME_COLUMN, GTK_SORT_ASCENDING);
gtk_tree_model_filter_set_visible_func (filtered_model,
filter_func,
NULL, NULL);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (filtered_list));
g_signal_connect (G_OBJECT (selection), "changed",
G_CALLBACK (selection_changed), builder);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (filtered_model), &iter))
gtk_tree_selection_select_iter (selection, &iter);
g_signal_connect (G_OBJECT (filtered_list), "row-activated",
G_CALLBACK (row_activated), builder);
gtk_widget_grab_focus (filter_entry);
gtk_widget_show (chooser);
return chooser;
}
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QWidget * main_wg = new QWidget;
// cria um objeto "splitter" para compartilhar widgets:
QSplitter *splitter = new QSplitter(main_wg);
// cria um "model" usando o "StandardModel"
QStandardItemModel *model = new QStandardItemModel;
const int totCols = 3;
int col;
// define os títulos das colunas:
for (col = 0; col < totCols; ++col)
{
model->setHorizontalHeaderItem(col,
new QStandardItem( QString("COL-%1").arg(col+1) ) );
}
// alimenta linhas, colunas e sub-níveis:
QStandardItem *parentItem = model->invisibleRootItem();
const int iniLevel = 0;
const int totLevels= 3;
QString prevRows("");
QVector<QSize> vec_ColsRows; // colunas, linhas de cada nível
vec_ColsRows.reserve( totLevels );
// quantidade-colunas, quantidade-linhas
vec_ColsRows << QSize(3,10) << QSize(3,3) << QSize(3,2) ;
populate_model ( parentItem, vec_ColsRows,
iniLevel, prevRows);
// Neste exemplo,
// O "model" foi alimentado com linhas, colunas e sub-níveis:
// E serão criadas 4 "views" (uma "tree", uma "table", uma "list" e uma "comboBox")
// relacionadas ao mesmo "model";
// Cada "view" exibe os dados de uma determinada maneira;
// 1- ==== a primeira "view" é uma "tree":
QTreeView *tree = new QTreeView(splitter);
tree->setModel(model);
// habilita classificação na tree:
tree->setSortingEnabled(true);
// classifica
tree->sortByColumn(0);
// expande toda a árvore:
tree->expandAll();
// força largura de todas as colunas
// para exibição completa do texto dos seus itens
for (col = 0; col < totCols; ++col)
tree->resizeColumnToContents(col);
// configura o header para permitir mudança na ordem de classificacão:
QHeaderView * hdrTree = tree->header();
hdrTree->setClickable (true);
hdrTree->setSortIndicator(0,Qt::AscendingOrder);
hdrTree->setSortIndicatorShown(true);
hdrTree->setMovable(true); // permite mover colunas do header
// 2- ==== a segunda "view" é uma "table"
QTableView *table = new QTableView(splitter);
table->setModel(model);
table->setAlternatingRowColors(true);
// habilita classificação na table:
table->setSortingEnabled(true);
// classifica
table->sortByColumn(0);
// configura o header para permitir mudança na ordem de classificacão:
QHeaderView * hdrTable = table->horizontalHeader();
hdrTable->setClickable (true);
hdrTable->setSortIndicator(0,Qt::AscendingOrder);
hdrTable->setSortIndicatorShown(true);
hdrTable->setMovable(true); // permite mover colunas do header
// 3- ==== a terceira view é uma "list":
QListView *list = new QListView(splitter);
list->setModel(model);
// 4- ==== a quarta "view" é uma "comboBox"
QComboBox *combo = new QComboBox;
combo->setModel(model);
// configura a "splitter" definindo a largura de cada "view"
int width = 800;
QList< int > cols;
cols << int(width* 0.45) << int(width*0.45) << int(width*0.1);
splitter->setSizes(cols);
// layout para agrupar a "combo" e a "splitter":
QGridLayout * glayMain = new QGridLayout;
main_wg->setLayout( glayMain);
glayMain->addWidget( combo, 0, 1); // linha 0, coluna 0;
glayMain->setRowMinimumHeight(1, glayMain->verticalSpacing() * 4); // linha 1: linha de separação
glayMain->addWidget( splitter, 2, 0, 1, 3 ); // linha 2, coluna 0, rowSpan 1, colSpan 3
main_wg->setWindowTitle("06_standard - 4 'views' usando o mesmo 'model' (StandardModel) - recursivo");
main_wg->resize(800,500);
main_wg->show();
return app.exec();
}
