foreach_slist (elem, file_list)
{
GtkTreeIter iter;
gchar **path_arr = elem->data;
GIcon *icon = NULL;
gchar *content_type = g_content_type_guess(path_arr[level], NULL, 0, NULL);
if (content_type)
{
icon = g_content_type_get_icon(content_type);
if (icon)
{
GtkIconInfo *icon_info;
icon_info = gtk_icon_theme_lookup_by_gicon(gtk_icon_theme_get_default(), icon, 16, 0);
if (!icon_info)
{
g_object_unref(icon);
icon = NULL;
}
else
gtk_icon_info_free(icon_info);
}
g_free(content_type);
}
if (patterns_match(header_patterns, path_arr[level]))
{
if (! icon)
icon = g_icon_new_for_string("prjorg-header", NULL);
gtk_tree_store_insert_with_values(s_file_store, &iter, parent, 0,
FILEVIEW_COLUMN_ICON, icon,
FILEVIEW_COLUMN_NAME, path_arr[level],
FILEVIEW_COLUMN_COLOR, project ? NULL : &s_external_color, -1);
}
else if (patterns_match(source_patterns, path_arr[level]))
{
if (! icon)
icon = g_icon_new_for_string("prjorg-source", NULL);
gtk_tree_store_insert_with_values(s_file_store, &iter, parent, 0,
FILEVIEW_COLUMN_ICON, icon,
FILEVIEW_COLUMN_NAME, path_arr[level],
FILEVIEW_COLUMN_COLOR, project ? NULL : &s_external_color, -1);
}
else
{
if (! icon)
icon = g_icon_new_for_string("prjorg-file", NULL);
gtk_tree_store_insert_with_values(s_file_store, &iter, parent, 0,
FILEVIEW_COLUMN_ICON, icon,
FILEVIEW_COLUMN_NAME, path_arr[level],
FILEVIEW_COLUMN_COLOR, project ? NULL : &s_external_color, -1);
}
if (icon)
g_object_unref(icon);
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *sw;
GtkWidget *tv;
GtkTreeViewColumn *col;
GtkCellRenderer *cell;
GtkTreeStore *store;
GtkTreeIter iter;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), sw);
tv = gtk_tree_view_new ();
gtk_container_add (GTK_CONTAINER (sw), tv);
col = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_add_attribute (col, cell, "text", 0);
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_add_attribute (col, cell, "active", 1);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_add_attribute (col, cell, "text", 0);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_add_attribute (col, cell, "stock-id", 2);
cell = gtk_cell_renderer_toggle_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_add_attribute (col, cell, "active", 1);
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), col);
store = gtk_tree_store_new (3, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_STRING);
gtk_tree_store_insert_with_values (store, NULL, NULL, 0, 0, "One row", 1, FALSE, 2, "gtk-open", -1);
gtk_tree_store_insert_with_values (store, &iter, NULL, 1, 0, "Two row", 1, FALSE, 2, "gtk-file", -1);
gtk_tree_store_insert_with_values (store, NULL, &iter, 0, 0, "Three row", 1, FALSE, 2, "gtk-file", -1);
gtk_tree_view_set_model (GTK_TREE_VIEW (tv), GTK_TREE_MODEL (store));
g_signal_connect (tv, "button-release-event",
G_CALLBACK (release_event), NULL);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void
append_actions (GUPnPServiceProxy *proxy,
GUPnPServiceIntrospection *introspection,
const GList *actions,
GtkTreeStore *store,
GtkTreeIter *service_iter)
{
const GList *iter;
for (iter = actions; iter; iter = iter->next) {
GUPnPServiceActionInfo *info;
GtkTreeIter action_iter;
info = iter->data;
gtk_tree_store_insert_with_values
(store, &action_iter,
service_iter, -1,
0, get_icon_by_id (ICON_ACTION),
1, info->name,
2, proxy,
3, introspection,
4, info,
5, ICON_ACTION,
-1);
append_action_arguments (info->arguments,
store,
&action_iter);
}
}
static void
append_action_arguments (GList *arguments,
GtkTreeStore *store,
GtkTreeIter *action_iter)
{
const GList *iter;
for (iter = arguments; iter; iter = iter->next) {
GUPnPServiceActionArgInfo *info;
IconID icon_id;
info = iter->data;
if (info->direction == GUPNP_SERVICE_ACTION_ARG_DIRECTION_IN) {
icon_id = ICON_ACTION_ARG_IN;
} else {
icon_id = ICON_ACTION_ARG_OUT;
}
gtk_tree_store_insert_with_values
(store,
NULL, action_iter, -1,
0, get_icon_by_id (icon_id),
1, info->name,
4, info,
5, icon_id,
-1);
}
}
static void populate_profile_combo (GtkComboBox *combo)
{
GstEncodingTarget *target;
const GList *p;
GtkTreeModel *model;
model = GTK_TREE_MODEL (gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_STRING));
target = rb_gst_get_default_encoding_target ();
for (p = gst_encoding_target_get_profiles (target); p != NULL; p = p->next) {
GstEncodingProfile *profile = GST_ENCODING_PROFILE (p->data);
char *media_type;
media_type = rb_gst_encoding_profile_get_media_type (profile);
if (media_type == NULL) {
continue;
}
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model),
NULL, NULL, -1,
0, media_type,
1, gst_encoding_profile_get_description (profile),
-1);
g_free (media_type);
}
gtk_combo_box_set_model (GTK_COMBO_BOX (combo), model);
g_object_unref (model);
}
static void
append_service_tree (GUPnPServiceInfo *info,
GtkTreeStore *store,
GtkTreeIter *device_iter)
{
char *id;
id = gupnp_service_info_get_id (info);
if (id) {
GtkTreeIter *service_iter;
service_iter = g_slice_new (GtkTreeIter);
gtk_tree_store_insert_with_values
(store,
service_iter,
device_iter, -1,
0, get_icon_by_id (ICON_SERVICE),
1, id,
2, info,
5, ICON_SERVICE,
-1);
gupnp_service_info_get_introspection_async (info,
got_introspection,
service_iter);
g_free (id);
}
}
static void
tab_panel_browser_add_tab_cb (MidoriBrowser* browser,
GtkWidget* view,
MidoriExtension* extension)
{
GtkWidget* notebook = katze_object_get_object (browser, "notebook");
gint page = gtk_notebook_page_num (GTK_NOTEBOOK (notebook), view);
MidoriWebSettings* settings = midori_browser_get_settings (browser);
gboolean minimized = katze_object_get_boolean (view, "minimized");
GdkPixbuf* icon = midori_view_get_icon (MIDORI_VIEW (view));
const gchar* title = midori_view_get_display_title (MIDORI_VIEW (view));
GtkTreeModel* model = tab_panel_get_model_for_browser (browser);
if (minimized)
{
GtkWidget* toolbar = tab_panel_get_toolbar_for_browser (browser);
GtkWidget* image = gtk_image_new_from_pixbuf (
midori_view_get_icon (MIDORI_VIEW (view)));
GtkToolItem* toolitem = gtk_tool_button_new (image, NULL);
gtk_tool_item_set_tooltip_text (toolitem, title);
gtk_widget_show (image);
g_object_set_data (G_OBJECT (view), "tab-panel-ext-toolitem", toolitem);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
tab_panel_toggle_toolbook (toolbar);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (tab_panel_toolitem_clicked_cb), view);
g_signal_connect (gtk_bin_get_child (GTK_BIN (toolitem)), "button-press-event",
G_CALLBACK (tab_panel_toolitem_button_press_event_cb), view);
}
else
{
GtkTreeIter iter;
gboolean buttons = katze_object_get_boolean (settings, "close-buttons-on-tabs");
gint ellipsize = midori_view_get_label_ellipsize (MIDORI_VIEW (view));
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model),
&iter, NULL, page, 0, view, 1, GTK_STOCK_CLOSE, 2, buttons,
3, icon, 4, title, 5, ellipsize, 6, NULL, -1);
}
if (!g_signal_handler_find (view, G_SIGNAL_MATCH_FUNC,
g_signal_lookup ("notify", MIDORI_TYPE_VIEW), 0, NULL,
tab_panel_view_notify_minimized_cb, extension))
{
g_signal_connect (settings, "notify::close-buttons-on-tabs",
G_CALLBACK (tab_panel_settings_notify_cb), model);
g_signal_connect (view, "notify::minimized",
G_CALLBACK (tab_panel_view_notify_minimized_cb), extension);
g_signal_connect (view, "notify::icon",
G_CALLBACK (tab_panel_view_notify_icon_cb), extension);
g_signal_connect (view, "notify::title",
G_CALLBACK (tab_panel_view_notify_title_cb), extension);
}
g_object_unref (notebook);
}
static void
setup_filesystem_menu(FormatDialog* dialog)
{
GtkTreeStore* model;
model = gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN);
GtkComboBox* combo = dialog->fs_combo;
GtkCellRenderer* text_renderer;
gtk_combo_box_set_model(combo, GTK_TREE_MODEL(model));
dialog->fs_model = model;
/* Set up the column */
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(combo), (text_renderer = gtk_cell_renderer_text_new()), TRUE );
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(combo), text_renderer, "markup", FS_COLUMN_MARKUP );
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(combo), text_renderer, "sensitive", FS_COLUMN_SENSITIVE );
/* Add the default items */
gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/,
FS_COLUMN_REALNAME, "friendly_vfat",
FS_COLUMN_MARKUP, _("For all computers"),
FS_COLUMN_SENSITIVE, TRUE, -1);
gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/,
FS_COLUMN_REALNAME, "friendly_ext2",
FS_COLUMN_MARKUP, _("For Linux computers"),
FS_COLUMN_SENSITIVE, TRUE, -1);
gtk_tree_store_insert_with_values(model, NULL, NULL, 100 /*Always at end*/,
FS_COLUMN_REALNAME, "friendly_hfsplus",
FS_COLUMN_MARKUP, _("For Apple computers"),
FS_COLUMN_SENSITIVE, TRUE, -1);
GtkTreeIter parent = {0, NULL};
gtk_tree_store_insert_with_values(model, &parent, NULL, 100 /*Always at end*/,
FS_COLUMN_REALNAME, "specific_fs",
FS_COLUMN_MARKUP, _("Specific Filesystem"),
FS_COLUMN_SENSITIVE, TRUE, -1);
/* Populate the specific fs list */
struct _setup_fs_duple s;
s.model = model; s.parent = &parent;
dialog->fs_map = build_supported_fs_list();
g_hash_table_foreach(dialog->fs_map, setup_fs_cb, &s);
}
static void
append_state_variables (GUPnPServiceProxy *proxy,
GUPnPServiceIntrospection *introspection,
const GList *variables,
GtkTreeStore *store,
GtkTreeIter *service_iter)
{
const GList *iter;
GtkTreeIter variables_iter;
gtk_tree_store_insert_with_values (store,
&variables_iter,
service_iter, -1,
0, get_icon_by_id (ICON_VARIABLES),
1, _("State variables"),
5, ICON_VARIABLES,
-1);
for (iter = variables; iter; iter = iter->next) {
GUPnPServiceStateVariableInfo *info;
info = iter->data;
gtk_tree_store_insert_with_values
(store,
NULL, &variables_iter, -1,
0, get_icon_by_id (ICON_VARIABLE),
1, info->name,
2, proxy,
3, introspection,
4, info,
5, ICON_VARIABLE,
-1);
/* Set-up event notitications for variable */
gupnp_service_proxy_add_notify (proxy,
info->name,
info->type,
on_state_variable_changed,
NULL);
}
}
static void
setup_fs_cb(gpointer key, gpointer value, gpointer user_data)
{
gchar* current_fs = key;
struct _setup_fs_duple* s = user_data;
g_debug("Adding fs: %s", current_fs);
gtk_tree_store_insert_with_values(s->model, NULL, s->parent, 100 /*ditto*/,
FS_COLUMN_REALNAME, current_fs,
FS_COLUMN_MARKUP, current_fs,
FS_COLUMN_SENSITIVE, TRUE, -1); /* We update this later */
}
static void
append_device_tree (GUPnPDeviceInfo *info,
GtkTreeModel *model,
GtkTreeIter *parent_iter)
{
char *friendly_name;
friendly_name = gupnp_device_info_get_friendly_name (info);
if (friendly_name) {
GtkTreeIter device_iter;
GList *child;
gtk_tree_store_insert_with_values
(GTK_TREE_STORE (model),
&device_iter, parent_iter, -1,
0, get_icon_by_id (ICON_DEVICE),
1, friendly_name,
2, info,
5, ICON_DEVICE,
-1);
g_free (friendly_name);
schedule_icon_update (info, on_device_icon_available);
/* Append the embedded devices */
child = gupnp_device_info_list_devices (info);
while (child) {
append_device_tree (GUPNP_DEVICE_INFO (child->data),
model,
&device_iter);
g_object_unref (child->data);
child = g_list_delete_link (child, child);
}
/* Append the services */
child = gupnp_device_info_list_services (info);
while (child) {
append_service_tree (GUPNP_SERVICE_INFO (child->data),
GTK_TREE_STORE (model),
&device_iter);
g_object_unref (child->data);
child = g_list_delete_link (child, child);
}
}
}
static GtkTreeModel *
create_device_treemodel (void)
{
GtkTreeStore *store;
store = gtk_tree_store_new (6,
GDK_TYPE_PIXBUF, /* Icon */
G_TYPE_STRING, /* Name */
G_TYPE_OBJECT, /* Device/Service Info */
G_TYPE_OBJECT, /* Introspection */
G_TYPE_POINTER, /* non-object */
G_TYPE_UINT); /* icon type */
gtk_tree_store_insert_with_values (store, NULL, NULL, 0,
0, get_icon_by_id (ICON_NETWORK),
1, _("UPnP Network"),
5, ICON_NETWORK,
-1);
return GTK_TREE_MODEL (store);
}
static void
append_introspection (GUPnPServiceProxy *proxy,
GUPnPServiceIntrospection *introspection,
GtkTreeStore *store,
GtkTreeIter *service_iter)
{
const GList *list;
if (introspection == NULL) {
gtk_tree_store_insert_with_values (store,
NULL, service_iter, -1,
0, get_icon_by_id (ICON_MISSING),
1, _("Information not available"),
5, ICON_MISSING,
-1);
return;
}
list = gupnp_service_introspection_list_state_variables (
introspection);
if (list)
append_state_variables (proxy,
introspection,
list,
store,
service_iter);
list = gupnp_service_introspection_list_actions (introspection);
if (list)
append_actions (proxy,
introspection,
list,
store,
service_iter);
}
static void
store_add_node(GtkTreeStore * store, GtkTreeIter * parent,
trg_files_tree_node * node)
{
GtkTreeIter child;
GList *li;
if (node->name) {
gdouble progress =
file_get_progress(node->length, node->bytesCompleted);
gtk_tree_store_insert_with_values(store, &child, parent, INT_MAX,
FILESCOL_WANTED, node->enabled,
FILESCOL_PROGRESS, progress,
FILESCOL_SIZE, node->length,
FILESCOL_ID, node->index,
FILESCOL_PRIORITY,
node->priority, FILESCOL_NAME,
node->name, -1);
}
for (li = node->children; li; li = g_list_next(li))
store_add_node(store, node->name ? &child : NULL,
(trg_files_tree_node *) li->data);
}
static GtkTreeModel *
create_model (void)
{
GtkTreeStore *store;
GtkTreeIter iter;
store = gtk_tree_store_new (1, G_TYPE_STRING);
/* A tree store with some random words ... */
gtk_tree_store_insert_with_values (store, &iter, NULL, 0,
0, "File Manager", -1);
gtk_tree_store_insert_with_values (store, &iter, NULL, 0,
0, "Gossip", -1);
gtk_tree_store_insert_with_values (store, &iter, NULL, 0,
0, "System Settings", -1);
gtk_tree_store_insert_with_values (store, &iter, NULL, 0,
0, "The GIMP", -1);
gtk_tree_store_insert_with_values (store, &iter, NULL, 0,
0, "Terminal", -1);
gtk_tree_store_insert_with_values (store, &iter, NULL, 0,
0, "Word Processor", -1);
return GTK_TREE_MODEL (store);
}
static void
project_tree_selection_changed_cb (GtkTreeSelection *selection,
gpointer user_data)
{
GPInstructAnalyzerExamineeView *view = GPINSTRUCT_ANALYZER_EXAMINEE_VIEW (user_data);
GPInstructAnalyzerExamineeViewPrivate *priv = view->priv;
GtkTreeIter iter, iterItem, iterChoice;
GtkTreeModel *model;
guint struct_type;
GPInstructLogAnalyzerTest *test;
guint min;
gdouble sec;
guint children, frequency, score;
gdouble percentage, time_spent, ave_time_spent;
gchar *title_text, *children_text, *frequency_text, *score_text,
*percentage_text, *time_text, *ave_time_text;
gtk_tree_store_clear (priv->test_store);
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get (model, &iter,
PROJECT_STRUCT_TYPE_COLUMN, &struct_type,
PROJECT_STRUCT_POINTER_COLUMN, &test,
-1);
if (struct_type == STRUCT_TYPE_TEST)
{
GList *items = test->items;
guint item_num = 0;
while (items)
{
GPInstructLogAnalyzerItem *item = items->data;
children = item->choices_length;
frequency = item->times_answered;
score = item->times_correctly_answered;
percentage = (frequency?((gdouble) score/frequency):0) * 100;
time_spent = item->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
title_text = gpinstruct_lesson_test_get_item (test->object,
item_num);
children_text = g_strdup_printf ("%d", children);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->test_store,
&iterItem, NULL,
-1,
TEST_TITLE_COLUMN, title_text,
TEST_ITEMS_COLUMN, children_text,
TEST_FREQUENCY_COLUMN, frequency_text,
TEST_SCORE_COLUMN, score_text,
TEST_PERCENTAGE_COLUMN, percentage_text,
TEST_TIME_COLUMN, time_text,
TEST_AVE_TIME_COLUMN, ave_time_text,
-1);
g_free (title_text);
g_free (children_text);
g_free (frequency_text);
g_free (score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *choices = item->choices;
guint choice_num = 0;
while (choices)
{
GPInstructLogAnalyzerChoice *choice = choices->data;
if (test->is_string)
title_text = g_strdup (choice->string);
else
title_text = gpinstruct_lesson_test_get_choice (test->object,
item_num,
choice_num);
frequency = choice->times_chosen;
percentage = (item->times_answered?((gdouble) frequency/item->times_answered):0) * 100;
time_spent = choice->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
frequency_text = g_strdup_printf ("%d", frequency);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->test_store,
&iterChoice, &iterItem,
-1,
TEST_TITLE_COLUMN, title_text,
TEST_FREQUENCY_COLUMN, frequency_text,
TEST_PERCENTAGE_COLUMN, percentage_text,
TEST_TIME_COLUMN, time_text,
TEST_AVE_TIME_COLUMN, ave_time_text,
-1);
g_free (title_text);
g_free (frequency_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
choice_num++;
choices = choices->next;
}
item_num++;
items = items->next;
}
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->test_store), &iter))
{
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->test_treeview));
gtk_tree_selection_select_iter (selection, &iter);
GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->test_scrolledwindow));
gtk_adjustment_set_value (adjustment, gtk_adjustment_get_lower (adjustment));
}
}
}
}
static void
rows_reordered_two_levels (void)
{
GtkTreeIter iter1, iter2, iter3, iter4, iter5;
GtkTreeIter citer1, citer2, citer3, citer4, citer5;
GtkTreeModel *model;
GtkTreeModelRefCount *ref_model;
GtkTreeModel *sort_model;
GtkWidget *tree_view;
SignalMonitor *monitor;
GtkTreePath *path, *child_path;
GType column_types[] = { G_TYPE_INT };
int order[][5] =
{
{ 2, 3, 0, 1, 4 },
{ 4, 3, 2, 1, 0 },
{ 2, 1, 4, 3, 0 }
};
model = gtk_tree_model_ref_count_new ();
ref_model = GTK_TREE_MODEL_REF_COUNT (model);
gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
column_types);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
0, 30, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
0, 40, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
0, 10, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
0, 20, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
0, 60, -1);
/* Child level */
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer1, &iter1, 0,
0, 30, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer2, &iter1, 1,
0, 40, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer3, &iter1, 2,
0, 10, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer4, &iter1, 3,
0, 20, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer5, &iter1, 4,
0, 60, -1);
sort_model = gtk_tree_model_sort_new_with_model (model);
tree_view = gtk_tree_view_new_with_model (sort_model);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
monitor = signal_monitor_new (sort_model);
/* Sort */
path = gtk_tree_path_new ();
child_path = gtk_tree_path_new_from_indices (2, -1);
signal_monitor_append_signal_reordered (monitor,
ROWS_REORDERED,
path, order[0], 5);
signal_monitor_append_signal_reordered (monitor,
ROWS_REORDERED,
child_path, order[0], 5);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
0, GTK_SORT_ASCENDING);
signal_monitor_assert_is_empty (monitor);
check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
/* The parent node of the child level moved due to sorting */
check_sort_order (sort_model, GTK_SORT_ASCENDING, "2");
signal_monitor_append_signal_reordered (monitor,
ROWS_REORDERED,
path, order[1], 5);
signal_monitor_append_signal_reordered (monitor,
ROWS_REORDERED,
child_path, order[1], 5);
gtk_tree_path_free (child_path);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
0, GTK_SORT_DESCENDING);
signal_monitor_assert_is_empty (monitor);
check_sort_order (sort_model, GTK_SORT_DESCENDING, NULL);
/* The parent node of the child level moved due to sorting */
check_sort_order (sort_model, GTK_SORT_DESCENDING, "2");
child_path = gtk_tree_path_new_from_indices (0, -1);
signal_monitor_append_signal_reordered (monitor,
ROWS_REORDERED,
path, order[2], 5);
signal_monitor_append_signal_reordered (monitor,
ROWS_REORDERED,
child_path, order[2], 5);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID,
GTK_SORT_ASCENDING);
signal_monitor_assert_is_empty (monitor);
gtk_tree_path_free (path);
gtk_tree_path_free (child_path);
signal_monitor_free (monitor);
gtk_widget_destroy (tree_view);
g_object_unref (sort_model);
g_object_unref (ref_model);
}
static void
ref_count_reorder_two (void)
{
GtkTreeIter iter1, iter2, iter3, iter4, iter5;
GtkTreeIter citer1, citer2, citer3, citer4, citer5;
GtkTreeIter siter1, siter2, siter3, siter4, siter5;
GtkTreeIter sciter1, sciter2, sciter3, sciter4, sciter5;
GtkTreeModel *model;
GtkTreeModelRefCount *ref_model;
GtkTreeModel *sort_model;
GtkWidget *tree_view;
GType column_types[] = { G_TYPE_INT };
model = gtk_tree_model_ref_count_new ();
ref_model = GTK_TREE_MODEL_REF_COUNT (model);
gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
column_types);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
0, 30, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
0, 40, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
0, 10, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
0, 20, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
0, 60, -1);
/* Child level */
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer1, &iter1, 0,
0, 30, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer2, &iter1, 1,
0, 40, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer3, &iter1, 2,
0, 10, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer4, &iter1, 3,
0, 20, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &citer5, &iter1, 4,
0, 60, -1);
assert_root_level_unreferenced (ref_model);
sort_model = gtk_tree_model_sort_new_with_model (model);
tree_view = gtk_tree_view_new_with_model (sort_model);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
assert_node_ref_count (ref_model, &iter1, 2);
assert_node_ref_count (ref_model, &iter2, 1);
assert_node_ref_count (ref_model, &iter3, 1);
assert_node_ref_count (ref_model, &iter4, 1);
assert_node_ref_count (ref_model, &iter5, 1);
assert_level_referenced (ref_model, 1, &iter1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter1, &citer1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter2, &citer2);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter3, &citer3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter4, &citer4);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter5, &citer5);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter1);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &siter5);
assert_node_ref_count (ref_model, &iter1, 4);
assert_node_ref_count (ref_model, &iter2, 1);
assert_node_ref_count (ref_model, &iter3, 4);
assert_node_ref_count (ref_model, &iter4, 1);
assert_node_ref_count (ref_model, &iter5, 2);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter3);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_ref_node (GTK_TREE_MODEL (sort_model), &sciter1);
assert_node_ref_count (ref_model, &citer1, 2);
assert_node_ref_count (ref_model, &citer2, 1);
assert_node_ref_count (ref_model, &citer3, 3);
assert_node_ref_count (ref_model, &citer4, 1);
assert_node_ref_count (ref_model, &citer5, 4);
/* Sort */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
0, GTK_SORT_ASCENDING);
assert_node_ref_count (ref_model, &iter1, 4);
assert_node_ref_count (ref_model, &iter2, 1);
assert_node_ref_count (ref_model, &iter3, 4);
assert_node_ref_count (ref_model, &iter4, 1);
assert_node_ref_count (ref_model, &iter5, 2);
assert_node_ref_count (ref_model, &citer1, 2);
assert_node_ref_count (ref_model, &citer2, 1);
assert_node_ref_count (ref_model, &citer3, 3);
assert_node_ref_count (ref_model, &citer4, 1);
assert_node_ref_count (ref_model, &citer5, 4);
/* Re-translate the iters after sorting */
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter1, &iter1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter2, &iter2);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter3, &iter3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter4, &iter4);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &siter5, &iter5);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter1, &citer1);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter2, &citer2);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter3, &citer3);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter4, &citer4);
gtk_tree_model_sort_convert_child_iter_to_iter (GTK_TREE_MODEL_SORT (sort_model), &sciter5, &citer5);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter1);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &siter5);
assert_node_ref_count (ref_model, &iter1, 2);
assert_node_ref_count (ref_model, &iter2, 1);
assert_node_ref_count (ref_model, &iter3, 1);
assert_node_ref_count (ref_model, &iter4, 1);
assert_node_ref_count (ref_model, &iter5, 1);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter3);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter5);
gtk_tree_model_unref_node (GTK_TREE_MODEL (sort_model), &sciter1);
assert_level_referenced (ref_model, 1, &iter1);
gtk_widget_destroy (tree_view);
g_object_unref (sort_model);
assert_entire_model_unreferenced (ref_model);
g_object_unref (ref_model);
}
static void
grilo_browse_cb (GrlSource *grilo_source, guint operation_id, GrlMedia *media, guint remaining, RBGriloSource *source, const GError *error)
{
if (operation_id != source->priv->browse_op) {
return;
}
if (error != NULL) {
/* do something? */
rb_debug ("got error for %s: %s", grl_source_get_name (grilo_source), error->message);
source->priv->browse_op = 0;
return;
}
if (media != NULL) {
source->priv->browse_got_results = TRUE;
source->priv->browse_position++;
}
if (media && GRL_IS_MEDIA_BOX (media)) {
GtkTreeIter new_row;
if (source->priv->browse_container == NULL) {
/* insert at the end */
gtk_tree_store_insert_with_values (source->priv->browser_model,
&new_row,
NULL,
-1,
0, g_object_ref (media),
1, grl_media_get_title (media),
2, CONTAINER_UNKNOWN_MEDIA,
3, 0,
-1);
} else {
int n;
/* insert before the expand marker row */
n = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (source->priv->browser_model),
&source->priv->browse_container_iter);
gtk_tree_store_insert_with_values (source->priv->browser_model,
&new_row,
&source->priv->browse_container_iter,
n - 1,
0, g_object_ref (media),
1, grl_media_get_title (media),
2, CONTAINER_UNKNOWN_MEDIA,
3, 0,
-1);
}
/* and insert an expand marker below it too */
gtk_tree_store_insert_with_values (source->priv->browser_model,
NULL,
&new_row,
-1,
0, NULL,
1, "...", /* needs to be translatable? */
2, CONTAINER_NO_MEDIA,
3, 0,
-1);
} else if (media && GRL_IS_MEDIA_AUDIO (media)) {
source->priv->browse_got_media = TRUE;
}
if (remaining == 0) {
source->priv->browse_op = 0;
if (source->priv->browse_got_results == FALSE &&
source->priv->browse_container != NULL) {
/* no more results for this container, so delete the marker row */
delete_marker_row (source, &source->priv->browse_container_iter);
set_container_type (source, &source->priv->browse_container_iter, source->priv->browse_got_media);
gtk_tree_store_set (source->priv->browser_model,
&source->priv->browse_container_iter,
3, -1,
-1);
} else if (source->priv->browse_container != NULL) {
if (source->priv->browse_position >= CONTAINER_GIVE_UP_POINT &&
gtk_tree_model_iter_n_children (GTK_TREE_MODEL (source->priv->browser_model),
&source->priv->browse_container_iter) == 1) {
/* no containers yet, so remove the marker row */
delete_marker_row (source, &source->priv->browse_container_iter);
} else {
/* store browse position for next time we want more */
gtk_tree_store_set (source->priv->browser_model,
&source->priv->browse_container_iter,
3, source->priv->browse_position,
-1);
maybe_expand_container (source);
}
} else if (source->priv->browse_got_results && source->priv->browse_container == NULL) {
/* get all top-level containers */
browse_next (source);
}
}
}
static void
rebuild_volume_combo(FormatDialog* dialog)
{
g_assert(dialog && dialog->volume_model);
gboolean show_partitions = gtk_toggle_button_get_active(dialog->show_partitions);
if( !update_device_lists(dialog) )
return;
/* Iterate through the volume list and build the tree model. If we're
* listing partitions, it's a bit trickier: first we add all the drives,
* and make a udi=>GtkTreeIter table. Then we use that table to add
* the partitions to the correct drives */
GSList* treeiter_list = NULL, *device_list = dialog->hal_drive_list;
GSList* iter; gboolean not_empty = FALSE, can_format, listed_drives = FALSE;
GHashTable* udi_table = g_hash_table_new(g_str_hash, g_str_equal);
FormatVolume* current;
GtkTreeIter* parent_treeiter, *current_treeiter;
gtk_tree_store_clear(dialog->volume_model);
while(device_list != NULL) {
for(iter = device_list; iter != NULL; iter=iter->next) {
current = iter->data;
can_format = (current->volume ||
!libhal_drive_uses_removable_media(current->drive) ||
libhal_drive_is_media_detected(current->drive));
if(!current->friendly_name || strlen(current->friendly_name) == 0)
continue;
/* Look up the correct parent in the table */
parent_treeiter = NULL;
if(current->drive_udi)
parent_treeiter = g_hash_table_lookup(udi_table, current->drive_udi);
/*
if(parent_treeiter && !gtk_tree_store_iter_is_valid(dialog->volume_model, parent_treeiter)) {
g_warning("Iter wasn't valid! 0x%p", parent_treeiter);
parent_treeiter = NULL;
} */
treeiter_list = g_slist_prepend(treeiter_list, (current_treeiter = g_new0(GtkTreeIter, 1)) );
gtk_tree_store_insert_with_values(dialog->volume_model, current_treeiter, parent_treeiter, 1000,
DEV_COLUMN_UDI, current->udi,
DEV_COLUMN_NAME_MARKUP, current->friendly_name,
DEV_COLUMN_ICON, current->icon,
DEV_COLUMN_SENSITIVE, can_format, -1);
g_hash_table_insert(udi_table, current->udi, current_treeiter);
not_empty = TRUE;
}
device_list = NULL;
if(!listed_drives && show_partitions) {
listed_drives = TRUE;
device_list = dialog->hal_volume_list;
}
}
for(iter = treeiter_list; iter != NULL; iter = iter->next)
g_free((GtkTreeIter*)iter->data);
g_slist_free(treeiter_list);
g_hash_table_destroy(udi_table);
if(!not_empty) {
gtk_tree_store_insert_with_values(dialog->volume_model, NULL, NULL, 0,
DEV_COLUMN_NAME_MARKUP, _("<i>No devices found</i>"),
DEV_COLUMN_SENSITIVE, FALSE, -1);
}
}
static void
sorted_insert (void)
{
GtkTreeIter iter1, iter2, iter3, iter4, iter5, new_iter;
GtkTreeModel *model;
GtkTreeModelRefCount *ref_model;
GtkTreeModel *sort_model;
GtkWidget *tree_view;
SignalMonitor *monitor;
GtkTreePath *path;
GType column_types[] = { G_TYPE_INT };
int order0[] = { 1, 2, 3, 0, 4, 5, 6 };
model = gtk_tree_model_ref_count_new ();
ref_model = GTK_TREE_MODEL_REF_COUNT (model);
gtk_tree_store_set_column_types (GTK_TREE_STORE (model), 1,
column_types);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter1, NULL, 0,
0, 30, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter2, NULL, 1,
0, 40, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter3, NULL, 2,
0, 10, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter4, NULL, 3,
0, 20, -1);
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter5, NULL, 4,
0, 60, -1);
sort_model = gtk_tree_model_sort_new_with_model (model);
tree_view = gtk_tree_view_new_with_model (sort_model);
/* Sort */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model),
0, GTK_SORT_ASCENDING);
check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
monitor = signal_monitor_new (sort_model);
/* Insert a new item */
signal_monitor_append_signal (monitor, ROW_INSERTED, "4");
gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &new_iter, NULL,
5, 0, 50, -1);
signal_monitor_assert_is_empty (monitor);
check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
/* Sort the tree sort and append a new item */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (model),
0, GTK_SORT_ASCENDING);
check_sort_order (model, GTK_SORT_ASCENDING, NULL);
path = gtk_tree_path_new ();
signal_monitor_append_signal (monitor, ROW_INSERTED, "0");
signal_monitor_append_signal_reordered (monitor,
ROWS_REORDERED,
path, order0, 7);
signal_monitor_append_signal (monitor, ROW_CHANGED, "3");
gtk_tree_store_append (GTK_TREE_STORE (model), &new_iter, NULL);
gtk_tree_store_set (GTK_TREE_STORE (model), &new_iter, 0, 35, -1);
check_sort_order (model, GTK_SORT_ASCENDING, NULL);
check_sort_order (sort_model, GTK_SORT_ASCENDING, NULL);
gtk_tree_path_free (path);
signal_monitor_free (monitor);
gtk_widget_destroy (tree_view);
g_object_unref (sort_model);
g_object_unref (ref_model);
}
static void
examinee_tree_selection_changed_cb (GtkTreeSelection *selection,
gpointer user_data)
{
GPInstructAnalyzerExamineeView *view = GPINSTRUCT_ANALYZER_EXAMINEE_VIEW (user_data);
GPInstructAnalyzerExamineeViewPrivate *priv = view->priv;
GPInstructLogAnalyzerExaminee *examinee;
GtkTreeIter iter, iterProject, iterCategory, iterLesson, iterGroup;
GtkTreeModel *model;
guint min;
gdouble sec;
guint items, frequency, score;
gdouble ave_score, percentage, time_spent, ave_time_spent;
gchar *items_text, *frequency_text, *score_text, *ave_score_text, *percentage_text, *time_text, *ave_time_text;
gtk_tree_store_clear (priv->project_store);
if (gtk_tree_selection_get_selected (selection, &model, &iter))
{
gtk_tree_model_get (model, &iter,
EXAMINEE_STRUCT_POINTER_COLUMN, &examinee,
-1);
if (examinee)
{
GPInstructLogAnalyzerProject *project = examinee->project;
items = project->items_length;
frequency = project->times_taken;
score = project->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = project->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, &iterProject, NULL, -1,
PROJECT_TITLE_COLUMN, gpinstruct_project_get_title (project->object),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_PROJECT,
PROJECT_STRUCT_POINTER_COLUMN, project,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *categories = project->categories;
while (categories)
{
GPInstructLogAnalyzerCategory *category = (GPInstructLogAnalyzerCategory*) categories->data;
items = category->items_length;
frequency = category->times_taken;
score = category->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = category->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, &iterCategory, &iterProject, -1,
PROJECT_TITLE_COLUMN, gpinstruct_category_get_title (category->object),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_CATEGORY,
PROJECT_STRUCT_POINTER_COLUMN, category,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *lessons = category->lessons;
while (lessons)
{
GPInstructLogAnalyzerLesson *lesson = (GPInstructLogAnalyzerLesson*) lessons->data;
items = lesson->items_length;
frequency = lesson->times_taken;
score = lesson->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = lesson->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, &iterLesson, &iterCategory, -1,
PROJECT_TITLE_COLUMN, gpinstruct_lesson_get_title (lesson->object),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_LESSON,
PROJECT_STRUCT_POINTER_COLUMN, lesson,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *elements = lesson->elements;
while (elements)
{
if (((GPInstructLogAnalyzerLessonElement*) elements->data)->is_test)
{
GPInstructLogAnalyzerTest *test = ((GPInstructLogAnalyzerLessonElement*) elements->data)->test;
items = test->items_length;
frequency = test->times_taken;
score = test->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = test->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, NULL, &iterLesson, -1,
PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (test->object)),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_TEST,
PROJECT_STRUCT_POINTER_COLUMN, test,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
}
else
{
GPInstructLogAnalyzerGroup *group = ((GPInstructLogAnalyzerLessonElement*) elements->data)->group;
items = group->items_length;
frequency = group->times_taken;
score = group->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = group->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, &iterGroup, &iterLesson, -1,
PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (group->object)),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_GROUP,
PROJECT_STRUCT_POINTER_COLUMN, group,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
GList *tests = group->tests;
while (tests)
{
GPInstructLogAnalyzerTest *test = (GPInstructLogAnalyzerTest*) tests->data;
items = test->items_length;
frequency = test->times_taken;
score = test->items_correctly_answered;
ave_score = (frequency? (gdouble) score/frequency:0);
percentage = (items?(ave_score/items):0) * 100;
time_spent = test->time_spent;
ave_time_spent = frequency? time_spent/frequency:0;
items_text = g_strdup_printf ("%d", items);
frequency_text = g_strdup_printf ("%d", frequency);
score_text = g_strdup_printf ("%d", score);
ave_score_text = g_strdup_printf ("%.2f", ave_score);
percentage_text = g_strdup_printf ("%.2f%%", percentage);
min = time_spent / 60;
sec = time_spent - (min * 60);
time_text = g_strdup_printf ("%dm %.2fs", min, sec);
min = ave_time_spent / 60;
sec = ave_time_spent - (min * 60);
ave_time_text = g_strdup_printf ("%dm %.2fs", min, sec);
gtk_tree_store_insert_with_values (priv->project_store, NULL, &iterGroup, -1,
PROJECT_TITLE_COLUMN, gpinstruct_lesson_element_get_title (GPINSTRUCT_LESSON_ELEMENT (test->object)),
PROJECT_ITEMS_COLUMN, items_text,
PROJECT_FREQUENCY_COLUMN, frequency_text,
PROJECT_SCORE_COLUMN, score_text,
PROJECT_AVE_SCORE_COLUMN, ave_score_text,
PROJECT_PERCENTAGE_COLUMN, percentage_text,
PROJECT_TIME_COLUMN, time_text,
PROJECT_AVE_TIME_COLUMN, ave_time_text,
PROJECT_STRUCT_TYPE_COLUMN, STRUCT_TYPE_TEST,
PROJECT_STRUCT_POINTER_COLUMN, test,
-1);
g_free (items_text);
g_free (frequency_text);
g_free (score_text);
g_free (ave_score_text);
g_free (percentage_text);
g_free (time_text);
g_free (ave_time_text);
tests = tests->next;
}
}
elements = elements->next;
}
lessons = lessons->next;
}
categories = categories->next;
}
gtk_tree_view_expand_all (GTK_TREE_VIEW (priv->project_treeview));
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (priv->project_store), &iter))
{
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->project_treeview));
gtk_tree_selection_select_iter (selection, &iter);
GtkAdjustment *adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->project_scrolledwindow));
gtk_adjustment_set_value (adjustment, gtk_adjustment_get_lower (adjustment));
}
}
}
}
void
terminal_edit_keys_dialog_show (GtkWindow *transient_parent)
{
TerminalApp *app;
GtkWidget *dialog, *tree_view, *disable_mnemonics_button, *disable_menu_accel_button;
GtkTreeViewColumn *column;
GtkCellRenderer *cell_renderer;
GtkTreeStore *tree;
guint i;
if (edit_keys_dialog != NULL)
goto done;
if (!terminal_util_load_builder_file ("keybinding-editor.ui",
"keybindings-dialog", &dialog,
"disable-mnemonics-checkbutton", &disable_mnemonics_button,
"disable-menu-accel-checkbutton", &disable_menu_accel_button,
"accelerators-treeview", &tree_view,
NULL))
return;
app = terminal_app_get ();
terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MNEMONICS,
disable_mnemonics_button, 0);
terminal_util_bind_object_property_to_widget (G_OBJECT (app), TERMINAL_APP_ENABLE_MENU_BAR_ACCEL,
disable_menu_accel_button, 0);
/* Column 1 */
cell_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("_Action"),
cell_renderer,
"text", ACTION_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
gtk_tree_view_column_set_sort_column_id (column, ACTION_COLUMN);
/* Column 2 */
cell_renderer = gtk_cell_renderer_accel_new ();
g_object_set (cell_renderer,
"editable", TRUE,
"accel-mode", GTK_CELL_RENDERER_ACCEL_MODE_GTK,
NULL);
g_signal_connect (cell_renderer, "accel-edited",
G_CALLBACK (accel_edited_callback), tree_view);
g_signal_connect (cell_renderer, "accel-cleared",
G_CALLBACK (accel_cleared_callback), tree_view);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut _Key"));
gtk_tree_view_column_pack_start (column, cell_renderer, TRUE);
gtk_tree_view_column_set_cell_data_func (column, cell_renderer, accel_set_func, NULL, NULL);
gtk_tree_view_column_set_sort_column_id (column, KEYVAL_COLUMN);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
/* Add the data */
tree = edit_keys_store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER);
#ifdef MATE_ENABLE_DEBUG
_TERMINAL_DEBUG_IF (TERMINAL_DEBUG_ACCELS)
g_signal_connect (tree, "row-changed", G_CALLBACK (row_changed), NULL);
#endif
for (i = 0; i < G_N_ELEMENTS (all_entries); ++i)
{
GtkTreeIter parent_iter;
guint j;
gtk_tree_store_append (tree, &parent_iter, NULL);
gtk_tree_store_set (tree, &parent_iter,
ACTION_COLUMN, _(all_entries[i].user_visible_name),
-1);
for (j = 0; j < all_entries[i].n_elements; ++j)
{
KeyEntry *key_entry = &(all_entries[i].key_entry[j]);
GtkTreeIter iter;
gtk_tree_store_insert_with_values (tree, &iter, &parent_iter, -1,
ACTION_COLUMN, _(key_entry->user_visible_name),
KEYVAL_COLUMN, key_entry,
-1);
}
}
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (tree),
KEYVAL_COLUMN, accel_compare_func,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (tree), ACTION_COLUMN,
GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (tree));
g_object_unref (tree);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
g_signal_connect (notification_group, "accel-changed",
G_CALLBACK (treeview_accel_changed_cb), tree);
edit_keys_dialog = dialog;
g_signal_connect (dialog, "destroy",
G_CALLBACK (edit_keys_dialog_destroy_cb), tree);
g_signal_connect (dialog, "response",
G_CALLBACK (edit_keys_dialog_response_cb),
NULL);
gtk_window_set_default_size (GTK_WINDOW (dialog), -1, 350);
done:
gtk_window_set_transient_for (GTK_WINDOW (edit_keys_dialog), transient_parent);
gtk_window_present (GTK_WINDOW (edit_keys_dialog));
}
