int internal_cardtree_from_xml_file(cardtree_t *ct, GtkTreeIter *parent, FILE* F) { /* quick and dirty, absolutely no checking ! */ GtkTreeIter child; a_string_t *atr; a_string_t *elt; int retval = XML_ERROR; char *debug_msg; int in_element; elt = a_strnew(NULL); atr = a_strnew(NULL); while (!ferror(F)) { in_element = TOK_TEXT; if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up; if (in_element==TOK_END) { retval = XML_OK; goto clean_up; } else if (a_strequal(elt,"<node")) { gtk_tree_store_append (ct->_store, &child, parent); gtk_tree_store_set (ct->_store, &child, C_LEAF, 0, -1); for (;;) { if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up; if (in_element != TOK_ATTRIBUTE) break; if (assert_next_xml_token(F,atr,&in_element,"=")!=XML_OK) goto clean_up; if (get_next_xml_token(F,atr,&in_element)!=XML_OK) goto clean_up; if (in_element != TOK_STRING) goto clean_up; if (a_strequal(elt,"name")) { gtk_tree_store_set (ct->_store, &child, C_NODE, a_strval(atr), -1); } else if (a_strequal(elt,"id")) { gtk_tree_store_set (ct->_store, &child, C_ID, a_strval(atr), -1); } else if (a_strequal(elt,"length")) { gtk_tree_store_set (ct->_store, &child, C_LENGTH, a_strval(atr), -1); } else if (a_strequal(elt,"comment")) { gtk_tree_store_set (ct->_store, &child, C_COMMENT, a_strval(atr), -1); } else { log_printf(LOG_ERROR,"Unexpected XML attribute '%s'",a_strval(elt)); retval = XML_ERROR; goto clean_up; } } cardtree_create_markup(ct,&child); if (!a_strequal(elt,"/>")) { if (!a_strequal(elt,">")) { log_printf(LOG_ERROR,"Expected '>' or '/>'"); goto clean_up; } retval = internal_cardtree_from_xml_file(ct,&child,F); if (retval!=XML_OK) goto clean_up; /*if (assert_next_xml_token(F,elt,&in_element,"</node>")!=XML_OK) goto clean_up;*/ } } else if (a_strequal(elt,"<data")) { gtk_tree_store_append (ct->_store, &child, parent); gtk_tree_store_set (ct->_store, &child, C_LEAF, 1, -1); if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up; if (a_strequal(elt,"/>")) continue; if (!a_strequal(elt,">")) { log_printf(LOG_ERROR,"Expected '>' or '/>'"); goto clean_up; } if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up; if (in_element!=TOK_TEXT) { log_printf(LOG_ERROR,"Expected text inside <data>...</data>, got %s instead.", a_strval(elt)); goto clean_up; } gtk_tree_store_set (ct->_store, &child, C_NODE, a_strval(elt), -1); cardtree_create_markup(ct,&child); if (assert_next_xml_token(F,elt,&in_element,"</>")!=XML_OK) goto clean_up; } else if (a_strequal(elt,"<cardtree")) { if (parent!=NULL) { log_printf(LOG_ERROR,"XML ERROR - cardtree must be root element"); goto clean_up; } if (get_next_xml_token(F,elt,&in_element)!=XML_OK) goto clean_up; if (a_strequal(elt,"/>")) { retval = XML_OK; goto clean_up; } if (!a_strequal(elt,">")) { log_printf(LOG_ERROR,"Expected '>' or '/>'"); goto clean_up; } retval = internal_cardtree_from_xml_file(ct,NULL,F); if (retval!=XML_OK) goto clean_up; /*retval = assert_next_xml_token(F,elt,&in_element,"</cardtree>");*/ goto clean_up; } else if (in_element==TOK_INSTRUCTION) { /* NOP */ } else { log_printf(LOG_ERROR,"Syntax error : %s",a_strval(elt)); retval = XML_ERROR; goto clean_up; } } log_printf(LOG_ERROR,"Unexpected end-of-file or error in XML"); retval = XML_ERROR; clean_up: if (retval==XML_ERROR) { if (parent) { debug_msg = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(ct->_store),parent); log_printf(LOG_ERROR,"Error in path '%s'",debug_msg); g_free(debug_msg); } else log_printf(LOG_ERROR,"Error in root"); } a_strfree(atr); a_strfree(elt); return retval; }
static void create_and_fill_model() { GtkTreeStore *treestore; GtkTreeIter toplevel, child, child1; unsigned int iHelp1, iHelp2; gchar buf[64]; treestore = gtk_tree_store_new( NUM_COLS, G_TYPE_STRING, G_TYPE_UINT); if(bdk_window.decoder != NULL){ gtk_tree_store_append(treestore, &toplevel, NULL); gtk_tree_store_set( treestore, &toplevel, COL_VARIABLE, "SIZ", COL_VALUE, (guint) 0xFFFFFFFF, -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "Lsiz", COL_VALUE, (guint) get_SIZ_Lsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "Rsiz", COL_VALUE, (guint) get_SIZ_Rsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "Xsiz", COL_VALUE, (guint) get_SIZ_Xsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "Ysiz", COL_VALUE, (guint) get_SIZ_Ysiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "XOsiz", COL_VALUE, (guint) get_SIZ_XOsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "YOsiz", COL_VALUE, (guint) get_SIZ_YOsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "XTsiz", COL_VALUE, (guint) get_SIZ_XTsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "YTsiz", COL_VALUE, (guint) get_SIZ_YTsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "XTOsiz", COL_VALUE, (guint) get_SIZ_XTOsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "YTOsiz", COL_VALUE, (guint) get_SIZ_YTOsiz(bdk_window.decoder), -1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set(treestore, &child, COL_VARIABLE, "Csiz", COL_VALUE, (guint) get_SIZ_Csiz(bdk_window.decoder), -1); iHelp2 = get_SIZ_Csiz(bdk_window.decoder); for(iHelp1 = 0; iHelp1 < iHelp2; iHelp1++){ g_snprintf(buf, sizeof(buf),"Componente %u ", iHelp1); gtk_tree_store_append(treestore, &child, &toplevel); gtk_tree_store_set( treestore, &child, COL_VARIABLE, buf, COL_VALUE, (guint) 0xFFFFFFFF, -1); gtk_tree_store_append(treestore, &child1, &child); gtk_tree_store_set( treestore, &child1, COL_VARIABLE, "Ssiz", COL_VALUE, (guint) (guint) get_SIZ_Ssiz(bdk_window.decoder, (int) iHelp1), -1); gtk_tree_store_append(treestore, &child1, &child); gtk_tree_store_set( treestore, &child1, COL_VARIABLE, "XRsiz", COL_VALUE, (guint) (guint) get_SIZ_XRsiz(bdk_window.decoder, (int) iHelp1), -1); gtk_tree_store_append(treestore, &child1, &child); gtk_tree_store_set( treestore, &child1, COL_VARIABLE, "YRsiz", COL_VALUE, (guint) (guint) get_SIZ_YRsiz(bdk_window.decoder, (int) iHelp1), -1); } } bdk_window.model = GTK_TREE_MODEL(treestore); }
static GtkTreeModel * net_model_create (void) { GtkTreeModel *model; GtkTreeStore *store; GtkTreeIter new_iter; GtkTreeIter parent_iter; GtkTreeIter *parent_ptr; GtkTreePath *path; GtkTreeRowReference *row_ref; GHashTable *prefix_hash; char *display_name; char *hash_string; char **join_array; char **path_segments; int path_depth; int try_depth; store = gtk_tree_store_new (N_NET_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER); model = GTK_TREE_MODEL (store); /* Hash table stores GtkTreeRowReference for given path prefixes */ prefix_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) gtk_tree_row_reference_free); MENU_LOOP (&PCB->NetlistLib); { if (!menu->Name) continue; if (loading_new_netlist) menu->flag = TRUE; parent_ptr = NULL; path_segments = g_strsplit (menu->Name, NET_HIERARCHY_SEPARATOR, 0); path_depth = g_strv_length (path_segments); for (try_depth = path_depth - 1; try_depth > 0; try_depth--) { join_array = g_new0 (char *, try_depth + 1); memcpy (join_array, path_segments, sizeof (char *) * try_depth); /* See if this net's parent node is in the hash table */ hash_string = g_strjoinv (NET_HIERARCHY_SEPARATOR, join_array); g_free (join_array); row_ref = (GtkTreeRowReference *)g_hash_table_lookup (prefix_hash, hash_string); g_free (hash_string); /* If we didn't find the path at this level, keep looping */ if (row_ref == NULL) continue; path = gtk_tree_row_reference_get_path (row_ref); gtk_tree_model_get_iter (model, &parent_iter, path); parent_ptr = &parent_iter; break; } /* NB: parent_ptr may still be NULL if we reached the toplevel */ /* Now walk up the desired path, adding the nodes */ for (; try_depth < path_depth - 1; try_depth++) { display_name = g_strconcat (path_segments[try_depth], NET_HIERARCHY_SEPARATOR, NULL); gtk_tree_store_append (store, &new_iter, parent_ptr); gtk_tree_store_set (store, &new_iter, NET_ENABLED_COLUMN, "", NET_NAME_COLUMN, display_name, NET_LIBRARY_COLUMN, NULL, -1); g_free (display_name); path = gtk_tree_model_get_path (model, &new_iter); row_ref = gtk_tree_row_reference_new (model, path); parent_iter = new_iter; parent_ptr = &parent_iter; join_array = g_new0 (char *, try_depth + 2); memcpy (join_array, path_segments, sizeof (char *) * (try_depth + 1)); hash_string = g_strjoinv (NET_HIERARCHY_SEPARATOR, join_array); g_free (join_array); /* Insert those node in the hash table */ g_hash_table_insert (prefix_hash, hash_string, row_ref); /* Don't free hash_string, it is now oened by the hash table */ } gtk_tree_store_append (store, &new_iter, parent_ptr); gtk_tree_store_set (store, &new_iter, NET_ENABLED_COLUMN, menu->flag ? "" : "*", NET_NAME_COLUMN, path_segments[path_depth - 1], NET_LIBRARY_COLUMN, menu, -1); g_strfreev (path_segments); } END_LOOP; g_hash_table_destroy (prefix_hash); return model; }
static void gsslrtma_populate_tree_store(GncSxSlrTreeModelAdapter *model) { GtkTreeIter sx_tree_iter; GList *sx_iter; int instances_index = -1; for (sx_iter = model->instances->sx_instance_list; sx_iter != NULL; sx_iter = sx_iter->next) { GncSxInstances *instances = (GncSxInstances*)sx_iter->data; char last_occur_date_buf[MAX_DATE_LENGTH+1]; { const GDate *last_occur = xaccSchedXactionGetLastOccurDate(instances->sx); if (last_occur == NULL || !g_date_valid(last_occur)) { g_stpcpy(last_occur_date_buf, _("Never")); } else { qof_print_gdate(last_occur_date_buf, MAX_DATE_LENGTH, last_occur); } } if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(model->real), &sx_tree_iter, NULL, ++instances_index)) { gtk_tree_store_append(model->real, &sx_tree_iter, NULL); } gtk_tree_store_set(model->real, &sx_tree_iter, SLR_MODEL_COL_NAME, xaccSchedXactionGetName(instances->sx), SLR_MODEL_COL_INSTANCE_STATE, NULL, SLR_MODEL_COL_VARAIBLE_VALUE, NULL, SLR_MODEL_COL_INSTANCE_VISIBILITY, FALSE, SLR_MODEL_COL_VARIABLE_VISIBILITY, FALSE, SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY, FALSE, -1); // Insert instance information { GList *inst_iter; GtkTreeIter inst_tree_iter; char instance_date_buf[MAX_DATE_LENGTH+1]; int instance_index = -1; for (inst_iter = instances->instance_list; inst_iter != NULL; inst_iter = inst_iter->next) { GncSxInstance *inst = (GncSxInstance*)inst_iter->data; qof_print_gdate(instance_date_buf, MAX_DATE_LENGTH, &inst->date); if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(model->real), &inst_tree_iter, &sx_tree_iter, ++instance_index)) { gtk_tree_store_append(model->real, &inst_tree_iter, &sx_tree_iter); } gtk_tree_store_set(model->real, &inst_tree_iter, SLR_MODEL_COL_NAME, instance_date_buf, SLR_MODEL_COL_INSTANCE_STATE, _(gnc_sx_instance_state_names[inst->state]), SLR_MODEL_COL_VARAIBLE_VALUE, NULL, SLR_MODEL_COL_INSTANCE_VISIBILITY, TRUE, SLR_MODEL_COL_VARIABLE_VISIBILITY, FALSE, SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY, inst->state != SX_INSTANCE_STATE_CREATED, -1); // Insert variable information { GList *vars = NULL, *var_iter; GtkTreeIter var_tree_iter; gint visible_variable_index = -1; vars = gnc_sx_instance_get_variables(inst); for (var_iter = vars; var_iter != NULL; var_iter = var_iter->next) { GncSxVariable *var = (GncSxVariable*)var_iter->data; GString *tmp_str; if (!var->editable) continue; if (gnc_numeric_check(var->value) == GNC_ERROR_OK) { _var_numeric_to_string(&var->value, &tmp_str); } else { tmp_str = g_string_new(_("(Need Value)")); } if (!gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(model->real), &var_tree_iter, &inst_tree_iter, ++visible_variable_index)) { gtk_tree_store_append(model->real, &var_tree_iter, &inst_tree_iter); } gtk_tree_store_set(model->real, &var_tree_iter, SLR_MODEL_COL_NAME, var->name, SLR_MODEL_COL_INSTANCE_STATE, NULL, SLR_MODEL_COL_VARAIBLE_VALUE, tmp_str->str, SLR_MODEL_COL_INSTANCE_VISIBILITY, FALSE, SLR_MODEL_COL_VARIABLE_VISIBILITY, TRUE, SLR_MODEL_COL_INSTANCE_STATE_SENSITIVITY, FALSE - 1); g_string_free(tmp_str, TRUE); } g_list_free(vars); _consume_excess_rows(model->real, visible_variable_index, &inst_tree_iter, &var_tree_iter); } } // if there are more instance iters, remove _consume_excess_rows(model->real, instance_index, &sx_tree_iter, &inst_tree_iter); } } _consume_excess_rows(model->real, instances_index, NULL, &sx_tree_iter); }
static void contact_list_store_get_group (EmpathyContactListStore *store, const gchar *name, GtkTreeIter *iter_group_to_set, GtkTreeIter *iter_separator_to_set, gboolean *created) { EmpathyContactListStorePriv *priv; GtkTreeModel *model; GtkTreeIter iter_group; GtkTreeIter iter_separator; FindGroup fg; priv = GET_PRIV (store); memset (&fg, 0, sizeof (fg)); fg.name = name; model = GTK_TREE_MODEL (store); gtk_tree_model_foreach (model, (GtkTreeModelForeachFunc) contact_list_store_get_group_foreach, &fg); if (!fg.found) { if (created) { *created = TRUE; } gtk_tree_store_append (GTK_TREE_STORE (store), &iter_group, NULL); gtk_tree_store_set (GTK_TREE_STORE (store), &iter_group, EMPATHY_CONTACT_LIST_STORE_COL_ICON_STATUS, NULL, EMPATHY_CONTACT_LIST_STORE_COL_NAME, name, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, TRUE, EMPATHY_CONTACT_LIST_STORE_COL_IS_ACTIVE, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, -1); if (iter_group_to_set) { *iter_group_to_set = iter_group; } gtk_tree_store_append (GTK_TREE_STORE (store), &iter_separator, &iter_group); gtk_tree_store_set (GTK_TREE_STORE (store), &iter_separator, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, TRUE, -1); if (iter_separator_to_set) { *iter_separator_to_set = iter_separator; } } else { if (created) { *created = FALSE; } if (iter_group_to_set) { *iter_group_to_set = fg.iter; } iter_separator = fg.iter; if (gtk_tree_model_iter_next (model, &iter_separator)) { gboolean is_separator; gtk_tree_model_get (model, &iter_separator, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, &is_separator, -1); if (is_separator && iter_separator_to_set) { *iter_separator_to_set = iter_separator; } } } }
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 gboolean pgd_find_find_text (PgdFindDemo *demo) { PopplerPage *page; GList *matches; GTimer *timer; GtkTreeModel *model; page = poppler_document_get_page (demo->doc, demo->page_index); if (!page) { demo->page_index++; return demo->page_index < demo->n_pages; } model = gtk_tree_view_get_model (GTK_TREE_VIEW (demo->treeview)); timer = g_timer_new (); matches = poppler_page_find_text_with_options (page, gtk_entry_get_text (GTK_ENTRY (demo->entry)), demo->options); g_timer_stop (timer); if (matches) { GtkTreeIter iter; gchar *str; GList *l; gdouble height; gint n_match = 0; str = g_strdup_printf ("%d matches found on page %d in %.4f seconds", g_list_length (matches), demo->page_index + 1, g_timer_elapsed (timer, NULL)); gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, TITLE_COLUMN, str, VISIBLE_COLUMN, FALSE, PAGE_COLUMN, demo->page_index, -1); g_free (str); poppler_page_get_size (page, NULL, &height); for (l = matches; l && l->data; l = g_list_next (l)) { PopplerRectangle *rect = (PopplerRectangle *)l->data; GtkTreeIter iter_child; gchar *x1, *y1, *x2, *y2; gdouble tmp; str = g_strdup_printf ("Match %d", ++n_match); x1 = g_strdup_printf ("%.2f", rect->x1); y1 = g_strdup_printf ("%.2f", rect->y1); x2 = g_strdup_printf ("%.2f", rect->x2); y2 = g_strdup_printf ("%.2f", rect->y2); tmp = rect->y1; rect->y1 = height - rect->y2; rect->y2 = height - tmp; gtk_tree_store_append (GTK_TREE_STORE (model), &iter_child, &iter); gtk_tree_store_set (GTK_TREE_STORE (model), &iter_child, TITLE_COLUMN, str, X1_COLUMN, x1, Y1_COLUMN, y1, X2_COLUMN, x2, Y2_COLUMN, y2, VISIBLE_COLUMN, TRUE, PAGE_COLUMN, demo->page_index, PAGE_RECT, rect, -1); g_free (str); g_free (x1); g_free (y1); g_free (x2); g_free (y2); g_object_weak_ref (G_OBJECT (model), (GWeakNotify)poppler_rectangle_free, rect); } g_list_free (matches); } g_timer_destroy (timer); g_object_unref (page); demo->page_index++; pgd_find_update_progress (demo, demo->page_index); return demo->page_index < demo->n_pages; }
GtkWidget * gimp_action_view_new (GimpUIManager *manager, const gchar *select_action, gboolean show_shortcuts) { GtkTreeView *view; GtkTreeViewColumn *column; GtkCellRenderer *cell; GtkTreeStore *store; GtkTreeModel *filter; GtkAccelGroup *accel_group; GList *list; GtkTreePath *select_path = NULL; g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL); store = gtk_tree_store_new (GIMP_ACTION_VIEW_N_COLUMNS, G_TYPE_BOOLEAN, /* COLUMN_VISIBLE */ GTK_TYPE_ACTION, /* COLUMN_ACTION */ G_TYPE_STRING, /* COLUMN_STOCK_ID */ G_TYPE_STRING, /* COLUMN_LABEL */ G_TYPE_STRING, /* COLUMN_LABEL_CASEFOLD */ G_TYPE_STRING, /* COLUMN_NAME */ G_TYPE_UINT, /* COLUMN_ACCEL_KEY */ GDK_TYPE_MODIFIER_TYPE, /* COLUMN_ACCEL_MASK */ G_TYPE_CLOSURE); /* COLUMN_ACCEL_CLOSURE */ accel_group = gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (manager)); for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager)); list; list = g_list_next (list)) { GimpActionGroup *group = list->data; GList *actions; GList *list2; GtkTreeIter group_iter; gtk_tree_store_append (store, &group_iter, NULL); gtk_tree_store_set (store, &group_iter, GIMP_ACTION_VIEW_COLUMN_STOCK_ID, group->stock_id, GIMP_ACTION_VIEW_COLUMN_LABEL, group->label, -1); actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group)); actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare); for (list2 = actions; list2; list2 = g_list_next (list2)) { GtkAction *action = list2->data; const gchar *name = gtk_action_get_name (action); const gchar *stock_id = gtk_action_get_stock_id (action); gchar *label; gchar *label_casefold; guint accel_key = 0; GdkModifierType accel_mask = 0; GClosure *accel_closure = NULL; GtkTreeIter action_iter; if (strstr (name, "-menu") || strstr (name, "-popup") || name[0] == '<') continue; label = gimp_strip_uline (gtk_action_get_label (action)); if (! (label && strlen (label))) { g_free (label); label = g_strdup (name); } label_casefold = g_utf8_casefold (label, -1); if (show_shortcuts) { accel_closure = gtk_action_get_accel_closure (action); if (accel_closure) { GtkAccelKey *key; key = gtk_accel_group_find (accel_group, gimp_action_view_accel_find_func, accel_closure); if (key && key->accel_key && key->accel_flags & GTK_ACCEL_VISIBLE) { accel_key = key->accel_key; accel_mask = key->accel_mods; } } } gtk_tree_store_append (store, &action_iter, &group_iter); gtk_tree_store_set (store, &action_iter, GIMP_ACTION_VIEW_COLUMN_VISIBLE, TRUE, GIMP_ACTION_VIEW_COLUMN_ACTION, action, GIMP_ACTION_VIEW_COLUMN_STOCK_ID, stock_id, GIMP_ACTION_VIEW_COLUMN_LABEL, label, GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, label_casefold, GIMP_ACTION_VIEW_COLUMN_NAME, name, GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, accel_key, GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, accel_mask, GIMP_ACTION_VIEW_COLUMN_ACCEL_CLOSURE, accel_closure, -1); g_free (label); g_free (label_casefold); if (select_action && ! strcmp (select_action, name)) { select_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store), &action_iter); } } g_list_free (actions); } filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL); g_object_unref (store); view = g_object_new (GIMP_TYPE_ACTION_VIEW, "model", filter, "rules-hint", TRUE, NULL); g_object_unref (filter); gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter), GIMP_ACTION_VIEW_COLUMN_VISIBLE); GIMP_ACTION_VIEW (view)->manager = g_object_ref (manager); GIMP_ACTION_VIEW (view)->show_shortcuts = show_shortcuts; gtk_tree_view_set_search_column (GTK_TREE_VIEW (view), GIMP_ACTION_VIEW_COLUMN_LABEL); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Action")); cell = gtk_cell_renderer_pixbuf_new (); gtk_tree_view_column_pack_start (column, cell, FALSE); gtk_tree_view_column_set_attributes (column, cell, "stock-id", GIMP_ACTION_VIEW_COLUMN_STOCK_ID, 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", GIMP_ACTION_VIEW_COLUMN_LABEL, NULL); gtk_tree_view_append_column (view, column); if (show_shortcuts) { g_signal_connect (view, "button-press-event", G_CALLBACK (gimp_action_view_button_press), NULL); g_signal_connect (accel_group, "accel-changed", G_CALLBACK (gimp_action_view_accel_changed), view); column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Shortcut")); cell = gtk_cell_renderer_accel_new (); g_object_set (cell, "mode", GTK_CELL_RENDERER_MODE_EDITABLE, "editable", TRUE, NULL); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "accel-key", GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, "accel-mods", GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, NULL); g_signal_connect (cell, "accel-edited", G_CALLBACK (gimp_action_view_accel_edited), view); g_signal_connect (cell, "accel-cleared", G_CALLBACK (gimp_action_view_accel_cleared), view); gtk_tree_view_append_column (view, column); } column = gtk_tree_view_column_new (); gtk_tree_view_column_set_title (column, _("Name")); cell = gtk_cell_renderer_text_new (); gtk_tree_view_column_pack_start (column, cell, TRUE); gtk_tree_view_column_set_attributes (column, cell, "text", GIMP_ACTION_VIEW_COLUMN_NAME, NULL); gtk_tree_view_append_column (view, column); if (select_path) { gimp_action_view_select_path (GIMP_ACTION_VIEW (view), select_path); gtk_tree_path_free (select_path); } return GTK_WIDGET (view); }
void show_traceset_stats(StatisticViewerData * statistic_viewer_data) { Tab *tab = statistic_viewer_data->tab; int i, nb; LttvTraceset *ts; LttvTraceStats *tcs; LttvTracesetStats * tscs = lttvwindow_get_traceset_stats(tab); gchar * str, trace_str[PATH_LENGTH]; GtkTreePath * path; GtkTreeIter iter; GtkTreeStore * store = statistic_viewer_data->store_m; if(tscs->stats == NULL) return; #ifdef DEBUG lttv_attribute_write_xml(tscs->stats, stdout, 1, 4); #endif //DEBUG ts = tscs->parent.parent.ts; nb = lttv_traceset_number(ts); if(nb == 0) return; gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, NAME_COLUMN, "Traceset statistics", -1); path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter); str = gtk_tree_path_to_string (path); for(i = 0 ; i < nb ; i++) { if (LTTV_TRACESET_CONTEXT(tscs)->traces[i]->t->is_live) { statistic_viewer_data->live_trace_count++; } } if (statistic_viewer_data->live_trace_count) { LttvAttributeValue value; value = lttv_attribute_add(tscs->stats, g_quark_from_static_string("WARNING: Live traceset"), LTTV_STRING); /* TODO ybrosseau 2012-03-15: add cast to silent discard const warning... find a better way */ *(value.v_string) = (char *)live_msg; } g_hash_table_insert(statistic_viewer_data->statistic_hash, (gpointer)str, tscs->stats); show_tree(statistic_viewer_data, tscs->stats, &iter); //show stats for all traces for(i = 0 ; i < nb ; i++) { tcs = (LttvTraceStats *)(LTTV_TRACESET_CONTEXT(tscs)->traces[i]); #if 0 //FIXME desc = ltt_trace_system_description(tcs->parent.parent.t); LttTime start_time = ltt_trace_system_description_trace_start_time(desc); sprintf(trace_str, "Trace on system %s at time %lu.%09lu", ltt_trace_system_description_node_name(desc), start_time.tv_sec, start_time.tv_nsec); #endif //0 sprintf(trace_str, "%s", g_quark_to_string(ltt_trace_name(tcs->parent.parent.t))); /* TODO ybrosseau 2011-01-12: Reenable stats for live trace */ if (LTTV_TRACE_CONTEXT(tcs)->t->is_live) { strcat(trace_str, " [LIVE]"); gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter,NAME_COLUMN,trace_str,-1); path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter); str = gtk_tree_path_to_string (path); g_hash_table_insert(statistic_viewer_data->statistic_hash, (gpointer)str,0); } else { gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter,NAME_COLUMN,trace_str,-1); path = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &iter); str = gtk_tree_path_to_string (path); g_hash_table_insert(statistic_viewer_data->statistic_hash, (gpointer)str,tcs->stats); show_tree(statistic_viewer_data, tcs->stats, &iter); #ifdef DEBUG lttv_attribute_write_xml(tcs->stats, stdout, 3, 4); #endif //DEBUG } } }
void gtkui_cheats_fill_tree(char *filename) { // Fill the cheat list Xml xml; GtkTreeIter iter; bool enabled = false; char codebuf[9]; char descbuf[512]; gtkui_cheats_clear(); std::ifstream cheatfile(filename, std::ifstream::in|std::ifstream::binary); if (cheatfile.is_open()) { xml.Read(cheatfile); if (xml.GetRoot().IsType(L"cheats")) { Xml::Node root(xml.GetRoot()); Xml::Node node(root.GetFirstChild()); for (int i = 0; i < root.NumChildren(L"cheat"); i++) { wcstombs(descbuf, node.GetChild(L"description").GetValue(), sizeof(descbuf)); // Check if the cheat is enabled node.GetAttribute(L"enabled").IsValue(L"1") ? enabled = true : enabled = false; // Add the cheats to the list if (node.GetChild(L"genie")) { // Game Genie wcstombs(codebuf, node.GetChild(L"genie").GetValue(), sizeof(codebuf)); gtk_tree_store_append(treestore, &iter, NULL); gtk_tree_store_set(treestore, &iter, 0, enabled, 1, codebuf, 4, descbuf, -1); if (enabled) { cheats_code_gg_add(node.GetChild(L"genie").GetValue()); } } else if (node.GetChild(L"rocky")) { // Pro Action Rocky wcstombs(codebuf, node.GetChild(L"rocky").GetValue(), sizeof(codebuf)); gtk_tree_store_append(treestore, &iter, NULL); gtk_tree_store_set(treestore, &iter, 0, enabled, 2, codebuf, 4, descbuf, -1); if (enabled) { cheats_code_par_add(node.GetChild(L"rocky").GetValue()); } } else if (node.GetChild(L"address")) { // Raw char rawbuf[11]; snprintf(rawbuf, sizeof(rawbuf), "%04x %02x %02x", node.GetChild(L"address").GetUnsignedValue(), node.GetChild(L"value").GetUnsignedValue(), node.GetChild(L"compare").GetUnsignedValue()); gtk_tree_store_append(treestore, &iter, NULL); gtk_tree_store_set(treestore, &iter, 0, enabled, 3, rawbuf, 4, descbuf, -1); if (enabled) { cheats_code_raw_add(node); } } node = node.GetNextSibling(); } } cheatfile.close(); } }
void nav_tree_refresh_objects (GSQLNavigation *navigation, GtkTreeView *tv, GtkTreeIter *iter) { GSQL_TRACE_FUNC; GtkTreeModel *model; GtkTreeIter child; GtkTreeIter child_fake; GtkTreeIter child_last; gint n, id, o_id; gchar key[256]; gchar *sql = NULL; gchar *realname = NULL; gchar *name = NULL; gchar *owner = NULL; GSQLCursor * cursor; GSQLCursorState state; GSQLSession *session; GSQLWorkspace *workspace; GSQLVariable *var; GtkListStore *details; void *s_elements; guint n_elements; gchar *stock; model = gtk_tree_view_get_model(tv); n = gtk_tree_model_iter_n_children(model, iter); for (; n>1; n--) { gtk_tree_model_iter_children(model, &child, iter); gtk_tree_store_remove(GTK_TREE_STORE(model), &child); } gtk_tree_model_iter_children(model, &child_last, iter); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_REALNAME, &realname, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_SQL, &sql, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_OWNER, &owner, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_ID, &id, -1); session = gsql_session_get_active (); GSQL_DEBUG ("realname:[%s] sql:[%s] owner:[%s]", realname, sql, owner); switch (id) { case OBJECT_TYPES_ID: if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_object_types; GSQL_DEBUG ("types SQL: %s", sql); cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_NAME, G_TYPE_STRING, ":owner", G_TYPE_STRING, owner, G_TYPE_STRING, ":object_name", G_TYPE_STRING, "%", -1); s_elements = object_types; n_elements = G_N_ELEMENTS (object_types); stock = GSQLE_ORACLE_STOCK_OBJ_TYPES; break; case OBJECT_TYPE_BODIES_ID: if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_users_objects; cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_NAME, G_TYPE_STRING, ":owner", G_TYPE_STRING, owner, G_TYPE_STRING, ":object_name", G_TYPE_STRING, "%", G_TYPE_STRING, ":object_type", G_TYPE_STRING, "TYPE BODY", -1); s_elements = object_types; n_elements = G_N_ELEMENTS (object_types); stock = GSQLE_ORACLE_STOCK_OBJ_TYPE_BODIES; break; case COLLECTION_TYPES_ID: if (strncmp (owner, gsql_session_get_username (session), 64)) sql = (gchar *) sql_oracle_collection_types; GSQL_DEBUG ("collection SQL: %s", sql); cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_NAME, G_TYPE_STRING, ":owner", G_TYPE_STRING, owner, G_TYPE_STRING, ":object_name", G_TYPE_STRING, "%", -1); s_elements = object_types; n_elements = G_N_ELEMENTS (object_types); stock = GSQLE_ORACLE_STOCK_COLLECTIONS_TYPES; break; } if (state != GSQL_CURSOR_STATE_OPEN) { gsql_cursor_close (cursor); return; } var = g_list_nth_data(cursor->var_list, 0); n = 0; while (gsql_cursor_fetch (cursor, 1) > 0) { n++; if (var->value_type != G_TYPE_STRING) { GSQL_DEBUG ("The name of object should be a string (char *). Is the bug"); name = N_("Incorrect data"); } else { name = (gchar *) var->value; // make a key for a hash of details memset (key, 0, 256); g_snprintf (key, 255, "%x%s%d%s", session, owner, id, name); details = gsql_navigation_get_details (navigation, key); oracle_navigation_fill_details (cursor, details); } gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter); gtk_tree_store_set (GTK_TREE_STORE(model), &child, GSQL_NAV_TREE_ID, id, GSQL_NAV_TREE_OWNER, owner, GSQL_NAV_TREE_IMAGE, stock, GSQL_NAV_TREE_NAME, name, GSQL_NAV_TREE_REALNAME, name, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, object_types, GSQL_NAV_TREE_DETAILS, details, GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(object_types), -1); gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child); gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake, GSQL_NAV_TREE_ID, -1, GSQL_NAV_TREE_IMAGE, NULL, GSQL_NAV_TREE_NAME, N_("Processing..."), GSQL_NAV_TREE_REALNAME, NULL, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, NULL, GSQL_NAV_TREE_NUM_ITEMS, NULL, -1); } GSQL_DEBUG ("Items fetched: [%d]", n); if (n > 0) { name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", realname, n); gtk_tree_store_set (GTK_TREE_STORE(model), iter, GSQL_NAV_TREE_NAME, name, -1); g_free (name); } gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last); gsql_cursor_close (cursor); }
void texture_select_callback(GObject* obj, gpointer user_data) { GtkTreeView* param_tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "selected_texture_treeview")); GtkTreeStore* param_store = GTK_TREE_STORE(gtk_tree_view_get_model(param_tree)); GtkTreeView* image_tree = GTK_TREE_VIEW(gtk_builder_get_object(builder, "selected_texture_images")); GtkTreeStore* image_store = GTK_TREE_STORE(gtk_tree_view_get_model(image_tree)); if (!param_store) return; if (!image_store) return; gtk_tree_store_clear(image_store); gtk_tree_store_clear(param_store); GtkTreePath* path; GtkSpinButton* layer_spinbutton = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "layer_spinbutton")); gtk_tree_view_get_cursor(GTK_TREE_VIEW(obj), &path, NULL); if (!path) { gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(layer_spinbutton), 0); return; } //Initialize params size_t tex_index = gtk_tree_path_get_indices(path)[0]; inspect_texture_t* tex = get_inspect_tex_vec(inspector->textures, tex_index); if (!tex) return; gtk_adjustment_set_upper(gtk_spin_button_get_adjustment(layer_spinbutton), tex->layer_count-1); inspect_gl_tex_params_t params = tex->params; GtkTreeIter row; #define VAL(name, val) gtk_tree_store_append(param_store, &row, NULL);\ gtk_tree_store_set(param_store, &row, 0, (name), 1, (val), -1); if (tex->type) { VAL("Type", static_format("%s", get_enum_str("TextureTarget", tex->type))); VAL("Depth Stencil Mode", static_format("%s", get_enum_str(NULL, params.depth_stencil_mode))); VAL("Min Filter", static_format("%s", get_enum_str("TextureMinFilter", params.min_filter))); VAL("Mag Filter", static_format("%s", get_enum_str("TextureMagFilter", params.mag_filter))); VAL("Min LOD", static_format("%s", format_float(params.min_lod))); VAL("Max LOD", static_format("%s", format_float(params.max_lod))); VAL("LOD bias", static_format("%s", format_float(params.lod_bias))); VAL("Base Level", static_format("%d", params.base_level)); VAL("Max Level", static_format("%d", params.max_level)); VAL("Swizzle", static_format("[%s, %s, %s, %s]", get_enum_str(NULL, params.swizzle[0]), get_enum_str(NULL, params.swizzle[1]), get_enum_str(NULL, params.swizzle[2]), get_enum_str(NULL, params.swizzle[3]))); VAL("Wrap S", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0]))); VAL("Wrap T", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0]))); VAL("Wrap R", static_format("%s", get_enum_str("TextureWrapMode", params.wrap[0]))); VAL("Border Color", static_format("[%s, %s, %s, %s]", format_float(params.border_color[0]), format_float(params.border_color[1]), format_float(params.border_color[2]), format_float(params.border_color[3]))); VAL("Compare Mode", static_format("%s", get_enum_str(NULL, params.compare_mode))); VAL("Compare Func", static_format("%s", get_enum_str("DepthFunction", params.compare_func))); VAL("View Min Level", static_format("%d", params.view_min_level)); VAL("View Num Levels", static_format("%u", params.view_num_levels)); VAL("View Min Layer", static_format("%d", params.view_min_layer)); VAL("View Num Layers", static_format("%u", params.view_num_layers)); VAL("Immutable levels", static_format("%u", params.immutable_levels)); VAL("Image Format Compat Type", static_format("%s", get_enum_str(NULL, params.image_format_compatibility_type))); VAL("Immutable Format", static_format("%s", get_enum_str(NULL, params.immutable_format))); } if (tex->mipmaps) { VAL("Width", static_format("%zu", tex->width)); VAL("Height", static_format("%zu", tex->height)); VAL("Depth", static_format("%zu", tex->depth)); VAL("Mipmap Count", static_format("%zu", tex->mipmap_count)); VAL("Layer Count", static_format("%zu", tex->layer_count)); #undef VAL GtkSpinButton* layer_button = GTK_SPIN_BUTTON(gtk_builder_get_object(builder, "layer_spinbutton")); uint32_t layer = gtk_spin_button_get_value(GTK_SPIN_BUTTON(layer_button)); GtkComboBox* face_combobox = GTK_COMBO_BOX(gtk_builder_get_object(builder, "face_combobox")); gint face = gtk_combo_box_get_active(GTK_COMBO_BOX(face_combobox)); //Initialize images size_t w = tex->width; size_t h = tex->height; for (size_t level = 0; level < tex->mipmap_count; level++) { inspect_image_t* img = inspect_get_tex_mipmap(tex, level, layer, face); if (img->has_data) { uint32_t* data = (uint32_t*)malloc(w*h*4); inspect_get_image_data(img, data); GtkTreeIter row; gtk_tree_store_append(image_store, &row, NULL); GdkPixbuf* pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8, w, h); uint32_t* dest = (uint32_t*)gdk_pixbuf_get_pixels(pixbuf); for (size_t y = 0; y < h; y++) { for (size_t x = 0; x < w; x++) { dest[(h-1-y)*w+x] = data[y*w+x]; } } gtk_tree_store_set(image_store, &row, 0, static_format("%u", level), 1, pixbuf, -1); g_object_unref(pixbuf); free(data); } w /= 2; h /= 2; } } }
static GtkTreeModel * create_capital_store (void) { struct { gchar *group; gchar *capital; } capitals[] = { { "A - B", NULL }, { NULL, "Albany" }, { NULL, "Annapolis" }, { NULL, "Atlanta" }, { NULL, "Augusta" }, { NULL, "Austin" }, { NULL, "Baton Rouge" }, { NULL, "Bismarck" }, { NULL, "Boise" }, { NULL, "Boston" }, { "C - D", NULL }, { NULL, "Carson City" }, { NULL, "Charleston" }, { NULL, "Cheyenne" }, { NULL, "Columbia" }, { NULL, "Columbus" }, { NULL, "Concord" }, { NULL, "Denver" }, { NULL, "Des Moines" }, { NULL, "Dover" }, { "E - J", NULL }, { NULL, "Frankfort" }, { NULL, "Harrisburg" }, { NULL, "Hartford" }, { NULL, "Helena" }, { NULL, "Honolulu" }, { NULL, "Indianapolis" }, { NULL, "Jackson" }, { NULL, "Jefferson City" }, { NULL, "Juneau" }, { "K - O" }, { NULL, "Lansing" }, { NULL, "Lincoln" }, { NULL, "Little Rock" }, { NULL, "Madison" }, { NULL, "Montgomery" }, { NULL, "Montpelier" }, { NULL, "Nashville" }, { NULL, "Oklahoma City" }, { NULL, "Olympia" }, { NULL, "P - S" }, { NULL, "Phoenix" }, { NULL, "Pierre" }, { NULL, "Providence" }, { NULL, "Raleigh" }, { NULL, "Richmond" }, { NULL, "Sacramento" }, { NULL, "Salem" }, { NULL, "Salt Lake City" }, { NULL, "Santa Fe" }, { NULL, "Springfield" }, { NULL, "St. Paul" }, { "T - Z", NULL }, { NULL, "Tallahassee" }, { NULL, "Topeka" }, { NULL, "Trenton" }, { NULL, NULL } }; GtkTreeIter iter, iter2; GtkTreeStore *store; gint i; store = gtk_tree_store_new (1, G_TYPE_STRING); for (i = 0; capitals[i].group || capitals[i].capital; i++) { if (capitals[i].group) { gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, 0, capitals[i].group, -1); } else if (capitals[i].capital) { gtk_tree_store_append (store, &iter2, &iter); gtk_tree_store_set (store, &iter2, 0, capitals[i].capital, -1); } } return GTK_TREE_MODEL (store); }
void nav_tree_refresh_views (GSQLNavigation *navigation, GtkTreeView *tv, GtkTreeIter *iter) { GSQL_TRACE_FUNC; GtkTreeModel *model; GtkListStore *details; GSQLNavigation *nav = NULL; gchar *sql = NULL; gchar *realname = NULL; gchar *owner = NULL; gint id; gint i,n; GtkTreeIter child; GtkTreeIter child_fake; GtkTreeIter child_last; GSQLCursor *cursor; GSQLVariable *var, *tmp = NULL; GSQLCursorState state; GSQLSession *session; gchar *name; gchar *key; guint length = 0; model = gtk_tree_view_get_model(tv); n = gtk_tree_model_iter_n_children(model, iter); for (; n>1; n--) { gtk_tree_model_iter_children(model, &child, iter); gtk_tree_store_remove(GTK_TREE_STORE(model), &child); } gtk_tree_model_iter_children(model, &child_last, iter); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_REALNAME, &realname, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_SQL, &sql, -1); gtk_tree_model_get (model, iter, GSQL_NAV_TREE_OWNER, &owner, -1); session = gsql_session_get_active (); cursor = gsql_cursor_new (session, sql); state = gsql_cursor_open_with_bind (cursor, FALSE, GSQL_CURSOR_BIND_BY_POS, G_TYPE_STRING, owner, -1); var = g_list_nth_data(cursor->var_list,0); if (state != GSQL_CURSOR_STATE_OPEN) { gsql_cursor_close (cursor); return; } i = 0; while (gsql_cursor_fetch (cursor, 1) > 0) { i++; if (var->value_type != G_TYPE_STRING) { GSQL_DEBUG ("The name of object should be a string (char *). Is the bug"); name = N_("Incorrect data"); } else { if (var->raw_to_value) { tmp = g_malloc0(sizeof(GSQLVariable)); memcpy(tmp, var, sizeof(GSQLVariable)); var->raw_to_value (tmp); } name = (gchar *) var->value; // make a key for a hash of details length = g_snprintf (NULL,0, "%x%s%d%s", session, name, VIEW_ID, name); key = g_malloc0(length); memset (key, 0, length); g_snprintf (key, length - 1, "%x%s%d%s", session, name, VIEW_ID, name); details = gsql_navigation_get_details (navigation, key); firebird_navigation_fill_details (cursor, details); } gtk_tree_store_append (GTK_TREE_STORE(model), &child, iter); gtk_tree_store_set (GTK_TREE_STORE(model), &child, GSQL_NAV_TREE_ID, VIEW_ID, GSQL_NAV_TREE_OWNER, owner, GSQL_NAV_TREE_IMAGE, GSQL_STOCK_VIEWS, GSQL_NAV_TREE_NAME, name, GSQL_NAV_TREE_REALNAME, name, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, nav_tree_views_popup, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, // FIXME:nav_tree_views_editor, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, nav_tree_views_event, GSQL_NAV_TREE_STRUCT, views, GSQL_NAV_TREE_DETAILS, details, GSQL_NAV_TREE_NUM_ITEMS, G_N_ELEMENTS(views), -1); gtk_tree_store_append (GTK_TREE_STORE (model), &child_fake, &child); gtk_tree_store_set (GTK_TREE_STORE (model), &child_fake, GSQL_NAV_TREE_ID, -1, GSQL_NAV_TREE_IMAGE, NULL, GSQL_NAV_TREE_NAME, N_("Processing..."), GSQL_NAV_TREE_REALNAME, NULL, GSQL_NAV_TREE_ITEM_INFO, NULL, GSQL_NAV_TREE_SQL, NULL, GSQL_NAV_TREE_OBJECT_POPUP, NULL, GSQL_NAV_TREE_OBJECT_HANDLER, NULL, GSQL_NAV_TREE_EXPAND_HANDLER, NULL, GSQL_NAV_TREE_EVENT_HANDLER, NULL, GSQL_NAV_TREE_STRUCT, NULL, GSQL_NAV_TREE_NUM_ITEMS, NULL, -1); g_free (key); if (tmp) g_free(tmp); } GSQL_DEBUG ("Items fetched: [%d]", i); if (i > 0) { name = g_strdup_printf("%s<span weight='bold'> [%d]</span>", realname, i); gtk_tree_store_set (GTK_TREE_STORE(model), iter, GSQL_NAV_TREE_NAME, name, -1); g_free (name); } gtk_tree_store_remove(GTK_TREE_STORE(model), &child_last); gsql_cursor_close (cursor); }
static void ref_count_delete_row (void) { GtkTreeIter grandparent1, grandparent2, parent1, parent2; GtkTreeIter iter_parent1, iter_parent2; GtkTreeModel *model; GtkTreeModelRefCount *ref_model; GtkTreeModel *sort_model; GtkTreePath *path; GtkWidget *tree_view; model = gtk_tree_model_ref_count_new (); ref_model = GTK_TREE_MODEL_REF_COUNT (model); /* + grandparent1 * + grandparent2 * + parent1 * + iter_parent1 * + parent2 * + iter_parent2 * + iter_parent2 */ gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1); gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); assert_entire_model_unreferenced (ref_model); sort_model = gtk_tree_model_sort_new_with_model (model); tree_view = gtk_tree_view_new_with_model (sort_model); assert_root_level_referenced (ref_model, 1); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &parent2, 0); assert_level_unreferenced (ref_model, &parent1); assert_level_unreferenced (ref_model, &parent2); path = gtk_tree_path_new_from_indices (1, -1); gtk_tree_view_expand_row (GTK_TREE_VIEW (tree_view), path, TRUE); gtk_tree_path_free (path); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent1, 2); assert_node_ref_count (ref_model, &parent2, 2); assert_node_ref_count (ref_model, &iter_parent1, 1); assert_node_ref_count (ref_model, &iter_parent2, 1); gtk_tree_store_remove (GTK_TREE_STORE (model), &iter_parent2); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent1, 2); assert_level_referenced (ref_model, 1, &parent1); assert_node_ref_count (ref_model, &parent2, 2); assert_level_referenced (ref_model, 1, &parent2); gtk_tree_store_remove (GTK_TREE_STORE (model), &parent1); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent2, 2); assert_level_referenced (ref_model, 1, &parent2); gtk_tree_store_remove (GTK_TREE_STORE (model), &grandparent2); assert_node_ref_count (ref_model, &grandparent1, 1); gtk_tree_model_sort_clear_cache (GTK_TREE_MODEL_SORT (sort_model)); assert_node_ref_count (ref_model, &grandparent1, 1); gtk_widget_destroy (tree_view); assert_entire_model_unreferenced (ref_model); g_object_unref (sort_model); g_object_unref (ref_model); }
// Create a new bus from the current selection static void create_bus_button_clicked (GtkWidget *widget, gpointer data) { int row_type = -1 ; bus_layout_D *dialog = (bus_layout_D *)data ; GList *llTreeRefs = NULL, *llItr = NULL ; GtkTreeStore *ts = GTK_TREE_STORE (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tview))) ; GtkTreeIter itrBus, itr, itrSrc, itrSrcParent ; GtkTreeRowReference *refBus = NULL, *refSrcParent = NULL ; GtkTreePath *tp = NULL, *tpSrcParent = NULL ; llTreeRefs = get_selected_refs (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview))) ; if (NULL == llTreeRefs) return ; gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itr, tp = gtk_tree_row_reference_get_path (llTreeRefs->data)) ; gtk_tree_model_get (GTK_TREE_MODEL (ts), &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ; gtk_tree_path_free (tp) ; gtk_tree_store_prepend (ts, &itrBus, NULL) ; gtk_tree_store_set (ts, &itrBus, BUS_LAYOUT_MODEL_COLUMN_ICON, (row_type & ROW_TYPE_INPUT) ? QCAD_STOCK_BUS_INPUT : QCAD_STOCK_BUS_OUTPUT, BUS_LAYOUT_MODEL_COLUMN_NAME, _("Untitled Bus"), BUS_LAYOUT_MODEL_COLUMN_TYPE, (row_type & ROW_TYPE_INPUT) ? ROW_TYPE_BUS_INPUT : ROW_TYPE_BUS_OUTPUT, BUS_LAYOUT_MODEL_COLUMN_INDEX, -1, -1) ; refBus = gtk_tree_row_reference_new (GTK_TREE_MODEL (ts), tp = gtk_tree_model_get_path (GTK_TREE_MODEL (ts), &itrBus)) ; gtk_tree_path_free (tp) ; for (llItr = g_list_last (llTreeRefs) ; llItr != NULL ; llItr = llItr->prev) { gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrBus, tp = gtk_tree_row_reference_get_path (refBus)) ; gtk_tree_path_free (tp) ; gtk_tree_store_append (ts, &itr, &itrBus) ; gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrc, tp = gtk_tree_row_reference_get_path (llItr->data)) ; gtk_tree_path_free (tp) ; swap_model_iters_contents (GTK_TREE_MODEL (ts), &itrSrc, &itr) ; gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrc, tp = gtk_tree_row_reference_get_path (llItr->data)) ; if (gtk_tree_path_get_depth (tp) > 1) { gtk_tree_path_up (tpSrcParent = gtk_tree_path_copy (tp)) ; refSrcParent = (1 == gtk_tree_model_path_n_children (GTK_TREE_MODEL (ts), tpSrcParent)) ? gtk_tree_row_reference_new (GTK_TREE_MODEL (ts), tpSrcParent) : NULL ; gtk_tree_path_free (tpSrcParent) ; } gtk_tree_path_free (tp) ; gtk_tree_row_reference_free (llItr->data) ; // Remove cell from old location gtk_tree_store_remove (ts, &itrSrc) ; // The bus that owned the row we just moved has become empty - delete it if (NULL != refSrcParent) { tpSrcParent = gtk_tree_row_reference_get_path (refSrcParent) ; gtk_tree_model_get_iter (GTK_TREE_MODEL (ts), &itrSrcParent, tpSrcParent) ; gtk_tree_store_remove (ts, &itrSrcParent) ; gtk_tree_path_free (tpSrcParent) ; gtk_tree_row_reference_free (refSrcParent) ; refSrcParent = NULL ; } } gtk_tree_selection_select_path (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tview)), tp = gtk_tree_row_reference_get_path (refBus)) ; gtk_tree_path_free (tp) ; gtk_tree_row_reference_free (refBus) ; g_list_free (llTreeRefs) ; }
static void ref_count_row_ref (void) { GtkTreeIter grandparent1, grandparent2, parent1, parent2; GtkTreeIter iter_parent1, iter_parent2; GtkTreeModel *model; GtkTreeModelRefCount *ref_model; GtkTreeModel *sort_model; GtkWidget *tree_view; GtkTreePath *path; GtkTreeRowReference *row_ref; model = gtk_tree_model_ref_count_new (); ref_model = GTK_TREE_MODEL_REF_COUNT (model); /* + grandparent1 * + grandparent2 * + parent1 * + iter_parent1 * + parent2 * + iter_parent2 * + iter_parent2 */ gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent1, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &grandparent2, NULL); gtk_tree_store_append (GTK_TREE_STORE (model), &parent1, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent1, &parent1); gtk_tree_store_append (GTK_TREE_STORE (model), &parent2, &grandparent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); gtk_tree_store_append (GTK_TREE_STORE (model), &iter_parent2, &parent2); sort_model = gtk_tree_model_sort_new_with_model (model); tree_view = gtk_tree_view_new_with_model (sort_model); path = gtk_tree_path_new_from_indices (1, 1, 1, -1); row_ref = gtk_tree_row_reference_new (sort_model, path); gtk_tree_path_free (path); assert_node_ref_count (ref_model, &grandparent1, 1); /* Referenced because the node is visible, its child level is built * and referenced by the row ref. */ assert_node_ref_count (ref_model, &grandparent2, 3); assert_node_ref_count (ref_model, &parent1, 0); /* Referenced by the row ref and because its child level is built. */ assert_node_ref_count (ref_model, &parent2, 2); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 1); gtk_tree_row_reference_free (row_ref); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 2); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &parent2, 1); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 0); path = gtk_tree_path_new_from_indices (1, 1, 1, -1); row_ref = gtk_tree_row_reference_new (sort_model, path); gtk_tree_path_free (path); assert_node_ref_count (ref_model, &grandparent1, 1); /* Referenced because the node is visible, its child level is built * and referenced by the row ref. */ assert_node_ref_count (ref_model, &grandparent2, 3); assert_node_ref_count (ref_model, &parent1, 0); /* Referenced by the row ref and because its child level is built. */ assert_node_ref_count (ref_model, &parent2, 2); assert_node_ref_count (ref_model, &iter_parent1, 0); assert_node_ref_count (ref_model, &iter_parent2, 1); gtk_tree_store_remove (GTK_TREE_STORE (model), &parent2); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 1); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &iter_parent1, 0); gtk_tree_row_reference_free (row_ref); assert_node_ref_count (ref_model, &grandparent1, 1); assert_node_ref_count (ref_model, &grandparent2, 1); assert_node_ref_count (ref_model, &parent1, 0); assert_node_ref_count (ref_model, &iter_parent1, 0); gtk_widget_destroy (tree_view); g_object_unref (sort_model); assert_entire_model_unreferenced (ref_model); g_object_unref (ref_model); }
// start helpers static void swap_buses (GtkTreeModel *tm, GtkTreeSelection *sel, bus_layout_D *dialog, GtkTreePath *tpSrc, GtkTreePath *tpDst) { int Nix ; GtkTreeIter itr ; SWAP_BUSES_STRUCT src, dst ; SWAP_BUSES_STRUCT *min = NULL, *max = NULL ; EXP_ARRAY *ar_bSelSrc = NULL, *ar_bSelDst = NULL ; gboolean bDstExpanded = TRUE ; src.tp = gtk_tree_path_copy (tpSrc) ; gtk_tree_model_get_iter (tm, &(src.itr), tpSrc) ; src.icChildren = gtk_tree_model_iter_n_children (tm, &(src.itr)) ; dst.tp = gtk_tree_path_copy (tpDst) ; gtk_tree_model_get_iter (tm, &(dst.itr), tpDst) ; dst.icChildren = gtk_tree_model_iter_n_children (tm, &(dst.itr)) ; if (dst.icChildren < src.icChildren) { min = &dst ; max = &src ; } else { min = &src ; max = &dst ; } bDstExpanded = gtk_tree_view_row_expanded (gtk_tree_selection_get_tree_view (sel), dst.tp) ; g_signal_handlers_block_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ; for (Nix = 0 ; Nix < max->icChildren - min->icChildren ; Nix++) gtk_tree_store_append (GTK_TREE_STORE (tm), &itr, &(min->itr)) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; ar_bSelSrc = exp_array_new (sizeof (gboolean), 1) ; ar_bSelDst = exp_array_new (sizeof (gboolean), 1) ; exp_array_insert_vals (ar_bSelSrc, NULL, max->icChildren, 1, 0) ; exp_array_insert_vals (ar_bSelDst, NULL, max->icChildren, 1, 0) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { exp_array_index_1d (ar_bSelSrc, gboolean, Nix) = gtk_tree_selection_path_is_selected (sel, src.tp) ; exp_array_index_1d (ar_bSelDst, gboolean, Nix) = gtk_tree_selection_path_is_selected (sel, dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } gtk_tree_path_up (src.tp) ; gtk_tree_path_up (dst.tp) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { if (exp_array_index_1d (ar_bSelDst, gboolean, Nix)) gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), src.tp) ; if (exp_array_index_1d (ar_bSelSrc, gboolean, Nix)) gtk_tree_view_expand_to_path (gtk_tree_selection_get_tree_view (sel), dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } gtk_tree_path_up (src.tp) ; gtk_tree_path_up (dst.tp) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { swap_model_paths_contents (tm, src.tp, dst.tp) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } gtk_tree_path_up (src.tp) ; gtk_tree_path_up (dst.tp) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < max->icChildren ; Nix++) { GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, src.tp, exp_array_index_1d (ar_bSelDst, gboolean, Nix)) ; GTK_TREE_SELECTION_SET_PATH_SELECTED (sel, dst.tp, exp_array_index_1d (ar_bSelSrc, gboolean, Nix)) ; gtk_tree_path_next (src.tp) ; gtk_tree_path_next (dst.tp) ; } gtk_tree_path_up (src.tp) ; gtk_tree_path_up (dst.tp) ; swap_model_paths_contents (tm, src.tp, dst.tp) ; gtk_tree_path_down (src.tp) ; gtk_tree_path_down (dst.tp) ; for (Nix = 0 ; Nix < min->icChildren ; Nix++) gtk_tree_path_next (max->tp) ; if (gtk_tree_model_get_iter (tm, &itr, max->tp)) while (gtk_tree_store_remove (GTK_TREE_STORE (tm), &itr)) ; if (!bDstExpanded) { for (Nix = 0 ; Nix < ar_bSelDst->icUsed ; Nix++) if (exp_array_index_1d (ar_bSelDst, gboolean, Nix)) break ; if (Nix == ar_bSelDst->icUsed) { gtk_tree_path_up (src.tp) ; gtk_tree_view_collapse_row (gtk_tree_selection_get_tree_view (sel), src.tp) ; } } exp_array_free (ar_bSelSrc) ; exp_array_free (ar_bSelDst) ; gtk_tree_path_free (src.tp) ; gtk_tree_path_free (dst.tp) ; g_signal_handlers_unblock_matched (G_OBJECT (sel), G_SIGNAL_MATCH_FUNC, 0, 0, NULL, (gpointer)tree_view_selection_changed, NULL) ; tree_view_selection_changed (sel, dialog) ; }
GtkWidget * CChoosebook::create_tree() { GtkWidget *sw; GtkTreeStore *model; GtkTreeIter iter; gchar *filename; model = gtk_tree_store_new (3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_STRING); filename = g_build_filename(g_pReciteWord->userpath, "hardbooks", NULL); gtk_tree_store_append (model, &iter, NULL); gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("hardbooks"),2,filename, -1); create_tree_model(filename,model, &iter); g_free(filename); filename = g_build_filename(g_pReciteWord->userpath, "books", NULL); gtk_tree_store_append (model, &iter, NULL); gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("my books"),2,filename, -1); create_tree_model(filename,model, &iter); g_free(filename); gtk_tree_store_append (model, &iter, NULL); filename = g_build_filename(reciteword_data_dir, "books", NULL); gtk_tree_store_set (model, &iter, 0,Skin->choosebook.dir.p[0],1, _("books"),2, filename, -1); create_tree_model(filename,model, &iter); g_free(filename); tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE); g_object_unref (model); GtkCellRenderer *renderer_image; GtkCellRenderer *renderer_text; GtkTreeViewColumn *column; renderer_image = gtk_cell_renderer_pixbuf_new(); renderer_text = gtk_cell_renderer_text_new (); //g_object_set (G_OBJECT (renderer), "xalign", 0.0, NULL); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column,_("Directories")); gtk_tree_view_column_pack_start(column,renderer_image,FALSE); gtk_tree_view_column_add_attribute(column, renderer_image, "pixbuf",0); gtk_tree_view_column_pack_end(column,renderer_text,TRUE); gtk_tree_view_column_add_attribute(column, renderer_text, "text",1); gtk_tree_view_insert_column(GTK_TREE_VIEW(tree_view),column,-1); gtk_tree_view_column_set_clickable (column, TRUE); GtkTreeSelection *selection; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); gtk_tree_view_expand_all(GTK_TREE_VIEW(tree_view)); //gtk_tree_selection_set_select_function(selection,tree_selection_func,this,NULL); g_signal_connect (G_OBJECT (selection), "changed", G_CALLBACK (on_choosebook_tree_selection_changed), this); sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request(sw,Skin->choosebook.book_tree.w,Skin->choosebook.book_tree.h); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw), tree_view); gtk_widget_show(tree_view); return sw; }
int main(int argc, char *argv[]) { GtkWidget *main_window, *scroll; GtkWidget *treeview; GtkTreeViewColumn *column; GtkCellRenderer *name_renderer, *size_renderer; GtkTreeStore *store; GtkTreeIter categories[14]; GValue value = { 0, }; gint offset; uint32 res_counts[14]; uint32 res_sizes[14]; int i; Common::File in; uint32 index_pos; uint32 pos, len; gtk_init(&argc, &argv); if (argc != 2) { printf("Usage: %s filename\n", argv[0]); return EXIT_FAILURE; } in.open(argv[1], "rb"); if (!in.isOpen()) { printf("Couldn't open %s for reading\n", argv[1]); return EXIT_FAILURE; } /* Create the main window, scrollable in both directions */ main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(main_window), "CLUster Explorer"); gtk_window_set_default_size(GTK_WINDOW(main_window), 400, 400); g_signal_connect(G_OBJECT(main_window), "destroy", G_CALLBACK(main_window_destroy_cb), NULL); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); /* Create the tree view */ for (i = 0; i < ARRAYSIZE(res_counts); i++) { res_counts[i] = 0; res_sizes[i] = 0; } store = gtk_tree_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_INT); gtk_tree_sortable_set_default_sort_func(GTK_TREE_SORTABLE(store), compare_items, NULL, NULL); gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING); index_pos = in.readUint32LE(); in.seek(index_pos, SEEK_SET); for (;;) { GtkTreeIter iter; byte type; gchar *utf8_name; gchar name[34]; gchar *size; try { pos = in.readUint32LE(); len = in.readUint32LE(); } catch (...) { break; } size = make_size(len); index_pos = in.pos(); in.seek(pos, SEEK_SET); type = in.readByte(); in.readByte(); /* compType */ in.readUint32LE(); /* compSize */ in.readUint32LE(); /* decompSize */ in.read_noThrow(name, sizeof(name)); /* * We need to convert from Latin-1 to UTF-8. Otherwise the text * "CAFÉ" won't be displayed properly. */ utf8_name = g_convert(name, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL); if (!res_counts[type]) { gtk_tree_store_append(store, &categories[type], NULL); gtk_tree_store_set(store, &categories[type], NAME_COLUMN, getType(type), SIZE_COLUMN, "", TYPE_COLUMN, -1, POSITION_COLUMN, -1, LENGTH_COLUMN, -1, -1); } res_counts[type]++; res_sizes[type] += len; gtk_tree_store_append(store, &iter, &categories[type]); gtk_tree_store_set(store, &iter, NAME_COLUMN, utf8_name, SIZE_COLUMN, size, TYPE_COLUMN, type, POSITION_COLUMN, pos, LENGTH_COLUMN, len); in.seek(index_pos, SEEK_SET); } in.close(); for (i = 0; i < ARRAYSIZE(res_counts); i++) { if (res_counts[i]) { gchar size[80]; sprintf(size, "%s [%d]", make_size(res_sizes[i]), res_counts[i]); gtk_tree_store_set(store, &categories[i], SIZE_COLUMN, size, -1); } } treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE); g_signal_connect(G_OBJECT(treeview), "button-press-event", G_CALLBACK(tree_view_button_cb), argv[1]); /* The view now holds a reference. We can get rid of our own. */ g_object_unref(G_OBJECT(store)); name_renderer = gtk_cell_renderer_text_new(); size_renderer = gtk_cell_renderer_text_new(); g_value_init(&value, G_TYPE_FLOAT); g_value_set_float(&value, 1.0); g_object_set_property(G_OBJECT(size_renderer), "xalign", &value); gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(treeview), -1, "Name", name_renderer, "text", NAME_COLUMN, NULL); offset = gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW(treeview), -1, "Size", size_renderer, "text", SIZE_COLUMN, NULL); column = gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), offset - 1); gtk_tree_view_column_set_alignment(column, 1.0); gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(treeview)); gtk_container_add(GTK_CONTAINER(main_window), scroll); gtk_widget_show_all(GTK_WIDGET(main_window)); gtk_main(); return EXIT_SUCCESS; }
static void cb_dialog_data_slicer_create_model (DialogDataSlicer *state) { struct { GODataSlicerFieldType type; char const * type_name; GtkTreeIter iter; } field_type_labels[] = { { GDS_FIELD_TYPE_PAGE, N_("Filter") }, { GDS_FIELD_TYPE_ROW, N_("Row") }, { GDS_FIELD_TYPE_COL, N_("Column") }, { GDS_FIELD_TYPE_DATA, N_("Data") }, /* Must be last */ { GDS_FIELD_TYPE_UNSET, N_("Unused") } }; unsigned int i, j, n; GtkTreeStore *model; GtkTreeModel *smodel; model = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_POINTER, /* field */ G_TYPE_INT, /* field-type */ G_TYPE_STRING, /* field-name */ G_TYPE_INT); /* field-header-index */ smodel = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL (model)); gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (smodel), FIELD_HEADER_INDEX, cb_sort_by_header_index, NULL, NULL); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (smodel), FIELD_HEADER_INDEX, GTK_SORT_ASCENDING); for (i = 0 ; i < G_N_ELEMENTS (field_type_labels) ; i++) { gtk_tree_store_append (model, &field_type_labels[i].iter, NULL); gtk_tree_store_set (model, &field_type_labels[i].iter, FIELD, NULL, FIELD_TYPE, field_type_labels[i].type, FIELD_NAME, _(field_type_labels[i].type_name), FIELD_HEADER_INDEX, -1, -1); } n = go_data_slicer_num_fields (GO_DATA_SLICER (state->slicer)); for (i = 0 ; i < n ; i++) { GtkTreeIter child_iter; GODataSlicerField *field = go_data_slicer_get_field (GO_DATA_SLICER (state->slicer), i); GOString *name = go_data_slicer_field_get_name (field); gboolean used = FALSE; for (j = 0 ; j < G_N_ELEMENTS (field_type_labels) ; j++) { int header_index = (GDS_FIELD_TYPE_UNSET != field_type_labels[j].type) ? go_data_slicer_field_get_field_type_pos (field, field_type_labels[j].type) : (used ? -1 : 0); if (header_index >= 0) { used = TRUE; gtk_tree_store_append (model, &child_iter, &field_type_labels[j].iter); gtk_tree_store_set (model, &child_iter, FIELD, field, FIELD_TYPE, field_type_labels[j].type, FIELD_NAME, name->str, FIELD_HEADER_INDEX, header_index, -1); } } } gtk_tree_view_set_model (state->treeview, smodel); }
/*************************** * * * Encodings dialog window * * * **************************/ void gxi_edit_encodings_clicked_cb (GtkButton *button, GncXmlImportData *data) { GtkBuilder *builder; GtkWidget *dialog; GtkListStore *list_store; GtkTreeStore *tree_store; GtkTreeIter iter, parent, *parent_ptr; GList *encodings_bak, *enc_iter; const gchar *encoding; system_encoding_type *system_enc; gpointer enc_ptr; gint i, j; builder = gtk_builder_new(); gnc_builder_add_from_file (builder, "assistant-xml-encoding.glade", "encodings_dialog"); dialog = GTK_WIDGET(gtk_builder_get_object (builder, "encodings_dialog")); data->encodings_dialog = dialog; // Set the style context for this assistant so it can be easily manipulated with css gnc_widget_set_style_context (GTK_WIDGET(dialog), "GncAssistXmlEncoding"); gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, data); gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (data->assistant)); data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view")); data->custom_enc_entry = GTK_WIDGET(gtk_builder_get_object (builder, "custom_enc_entry")); /* set up selected encodings list */ data->selected_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "selected_encs_view")); list_store = gtk_list_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); for (enc_iter = data->encodings; enc_iter; enc_iter = enc_iter->next) { encoding = g_quark_to_string (GPOINTER_TO_UINT (enc_iter->data)); gtk_list_store_append (list_store, &iter); gtk_list_store_set (list_store, &iter, ENC_COL_STRING, encoding, ENC_COL_QUARK, enc_iter->data, -1); } gtk_tree_view_insert_column_with_attributes ( data->selected_encs_view, -1, NULL, gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL); gtk_tree_view_set_model (data->selected_encs_view, GTK_TREE_MODEL (list_store)); g_object_unref (list_store); /* set up system encodings list */ data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view")); tree_store = gtk_tree_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER); for (i = 0, system_enc = system_encodings; i < n_system_encodings; i++, system_enc++) { if (i == 0) { /* first system encoding */ parent_ptr = NULL; } else { parent_ptr = &iter; for (j = 0; j < system_enc->parent; j++) if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (tree_store), &parent, &iter)) { /* go up one level */ iter = parent; } else { /* no parent to toplevel element */ parent_ptr = NULL; } } if (system_enc->encoding) enc_ptr = GUINT_TO_POINTER (g_quark_from_string (system_enc->encoding)); else enc_ptr = NULL; gtk_tree_store_append (tree_store, &iter, parent_ptr); gtk_tree_store_set (tree_store, &iter, ENC_COL_STRING, gettext (system_enc->text), ENC_COL_QUARK, enc_ptr, -1); } gtk_tree_view_insert_column_with_attributes ( data->available_encs_view, -1, NULL, gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL); gtk_tree_view_set_model (data->available_encs_view, GTK_TREE_MODEL (tree_store)); g_object_unref (tree_store); /* run the dialog */ encodings_bak = g_list_copy (data->encodings); if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) { g_list_free (encodings_bak); if (!g_list_find (data->encodings, GUINT_TO_POINTER (data->default_encoding))) { /* choose top level encoding then */ data->default_encoding = GPOINTER_TO_UINT (data->encodings->data); } /* update whole page */ gxi_check_file (data); gxi_update_default_enc_combo (data); gxi_update_string_box (data); gxi_update_conversion_forward (data); } else { g_list_free (data->encodings); data->encodings = encodings_bak; } g_object_unref(G_OBJECT(builder)); gtk_widget_destroy (dialog); data->encodings_dialog = NULL; }
/* Test for GNOME bugzilla bug 359231 */ static void test_bug359231 (void) { int i; int height1, height2; GtkTreePath *path; GtkTreeIter iter, child; GtkTreeStore *store; GdkRectangle rect; ScrollFixture *fixture; /* See #359231. */ g_test_bug ("359231"); /* Create model (GtkTreeStore in this case) */ store = gtk_tree_store_new (1, G_TYPE_STRING); gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, 0, "Foo", -1); for (i = 0; i < 4; i++) { gtk_tree_store_append (store, &child, &iter); gtk_tree_store_set (store, &child, 0, "Two\nLines", -1); } fixture = g_new0 (ScrollFixture, 1); scroll_fixture_setup (fixture, GTK_TREE_MODEL (store), NULL); gtk_widget_show_all (fixture->window); while (gtk_events_pending ()) gtk_main_iteration (); /* Prepend some rows at the top, expand */ gtk_tree_store_prepend (store, &iter, NULL); gtk_tree_store_set (store, &iter, 0, "Foo", -1); gtk_tree_store_prepend (store, &child, &iter); gtk_tree_store_set (store, &child, 0, "Two\nLines", -1); gtk_tree_view_expand_all (GTK_TREE_VIEW (fixture->tree_view)); while (gtk_events_pending ()) gtk_main_iteration (); /* Test if height of row 0:0 is correct */ path = gtk_tree_path_new_from_indices (0, -1); gtk_tree_view_get_background_area (GTK_TREE_VIEW (fixture->tree_view), path, NULL, &rect); height1 = rect.height; gtk_tree_path_down (path); gtk_tree_view_get_background_area (GTK_TREE_VIEW (fixture->tree_view), path, NULL, &rect); height2 = rect.height; gtk_tree_path_free (path); g_assert (height2 > height1); /* Clean up; the tear down also cleans up the model */ scroll_fixture_teardown (fixture, NULL); }
static void add_row_to_tree(GtkTreeStore *store, char *value, int index, GtkTreeIter *row_iter, GtkTreeIter *parent) { gtk_tree_store_append(store, row_iter, parent); gtk_tree_store_set(store, row_iter, index, value, -1); }
static void contact_list_store_add_contact (EmpathyContactListStore *store, EmpathyContact *contact) { EmpathyContactListStorePriv *priv; GtkTreeIter iter; GList *groups = NULL, *l; TpConnection *connection; EmpathyContactListFlags flags = 0; priv = GET_PRIV (store); if (EMP_STR_EMPTY (empathy_contact_get_name (contact)) || (!priv->show_offline && !empathy_contact_is_online (contact))) { return; } if (priv->show_groups) { groups = empathy_contact_list_get_groups (priv->list, contact); } connection = empathy_contact_get_connection (contact); if (EMPATHY_IS_CONTACT_MANAGER (priv->list)) { flags = empathy_contact_manager_get_flags_for_connection ( EMPATHY_CONTACT_MANAGER (priv->list), connection); } /* If no groups just add it at the top level. */ if (!groups) { GtkTreeModel *model = GTK_TREE_MODEL (store); if (gtk_tree_model_get_iter_first (model, &iter)) do { EmpathyContact *c; gtk_tree_model_get (model, &iter, EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &c, -1); if (c == contact) { g_object_unref (c); return; } if (c != NULL) g_object_unref (c); } while (gtk_tree_model_iter_next (model, &iter)); gtk_tree_store_append (GTK_TREE_STORE (store), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (store), &iter, EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_AUDIO, EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_VIDEO, EMPATHY_CONTACT_LIST_STORE_COL_FLAGS, flags, -1); } /* Else add to each group. */ for (l = groups; l; l = l->next) { GtkTreeIter iter_group; contact_list_store_get_group (store, l->data, &iter_group, NULL, NULL); gtk_tree_store_insert_after (GTK_TREE_STORE (store), &iter, &iter_group, NULL); gtk_tree_store_set (GTK_TREE_STORE (store), &iter, EMPATHY_CONTACT_LIST_STORE_COL_NAME, empathy_contact_get_name (contact), EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, contact, EMPATHY_CONTACT_LIST_STORE_COL_IS_GROUP, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_IS_SEPARATOR, FALSE, EMPATHY_CONTACT_LIST_STORE_COL_CAN_AUDIO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_AUDIO, EMPATHY_CONTACT_LIST_STORE_COL_CAN_VIDEO_CALL, empathy_contact_get_capabilities (contact) & EMPATHY_CAPABILITIES_VIDEO, EMPATHY_CONTACT_LIST_STORE_COL_FLAGS, flags, -1); g_free (l->data); } g_list_free (groups); contact_list_store_contact_update (store, contact); }
static GtkTreeModel* create_model(GtkTreeModel *model , const char *str) { GtkTreeIter iter , citer , niter; GdkPixbuf *pixbuf; char *name , *impression , *sipuri; char *mobileno , *device , *carrier; int presence , size; char text[1024]; int carrierStatus , relationStatus , serviceStatus; char *pyname; GtkTreeStore *store = gtk_tree_store_new(COL_NUM , GDK_TYPE_PIXBUF , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_INT , G_TYPE_INT , G_TYPE_INT , G_TYPE_INT , G_TYPE_INT , G_TYPE_INT , G_TYPE_INT , G_TYPE_INT); if(str == NULL || *str == '\0') return GTK_TREE_MODEL(store); gtk_tree_model_get_iter_first(model , &iter); do{ if(gtk_tree_model_iter_children(model , &citer , &iter)){ do{ gtk_tree_model_get(model , &citer , B_PIXBUF_COL , &pixbuf , B_NAME_COL , &name , B_SIPURI_COL , &sipuri , B_STATE_COL , &presence , B_IMPRESSION_COL , &impression , B_PHONENUM_COL , &mobileno , B_CARRIER_COL , &carrier , B_CARRIERSTATUS_COL , &carrierStatus , B_RELATIONSTATUS_COL , &relationStatus , B_SERVICESTATUS_COL , &serviceStatus , B_SIZE_COL , &size , B_DEVICE_COL , &device , -1); size_t j; strcpy(text , str); for(j = 0; j < strlen(text) ; j++) text[j] = toupper(text[j]); pyname = get_pystring(name); if(strstr(pyname , text) != NULL){ gtk_tree_store_append(store , &niter , NULL); gtk_tree_store_set(store , &niter , B_PIXBUF_COL , pixbuf , B_NAME_COL , name , B_SIPURI_COL , sipuri , B_STATE_COL , presence , B_IMPRESSION_COL , impression , B_PHONENUM_COL , mobileno , B_CARRIER_COL , carrier , B_CARRIERSTATUS_COL , carrierStatus , B_RELATIONSTATUS_COL , relationStatus , B_SERVICESTATUS_COL , serviceStatus , B_SIZE_COL , size , B_DEVICE_COL , device , -1); } free(pyname); g_object_unref(pixbuf); free(name); free(sipuri); free(impression); free(mobileno); free(carrier); free(device); }while(gtk_tree_model_iter_next(model , &citer)); } }while(gtk_tree_model_iter_next(model , &iter)); return GTK_TREE_MODEL(store); }
void ctree_refresh(void) { GdkPixbuf *pix1, *pix2, *pix3, *pix4, *pix5, *pix6, *pix7; GdkPixbuf *pix9 = NULL; GtkTreeIter pareng_node; GtkTreeIter child_node; GNode *vars, *apps; int i, j; if (GFMFile.trees.vars == NULL) return; // place base nodes ctree_set_basetree(); memcpy(&pareng_node, &vars_node, sizeof(GtkTreeIter)); // load pixmaps pix1 = create_pixbuf("ctree_open_dir.xpm"); pix2 = create_pixbuf("TIicon2.ico"); pix3 = create_pixbuf("ctree_open_dir.xpm"); pix4 = create_pixbuf("attr_locked.xpm"); pix5 = create_pixbuf("attr_archived.xpm"); pix6 = create_pixbuf("TIicon4.ico"); pix7 = create_pixbuf("attr_none.xpm"); // variables tree vars = GFMFile.trees.vars; for (i = 0; i < (int)g_node_n_children(vars); i++) { GNode *parent = g_node_nth_child(vars, i); VarEntry *fe = (VarEntry *) (parent->data); if ((fe != NULL) || tifiles_calc_is_ti9x(GFMFile.model)) { char *utf8 = ticonv_varname_to_utf8(GFMFile.model, fe->name, -1); gtk_tree_store_append(tree, &pareng_node, &vars_node); gtk_tree_store_set(tree, &pareng_node, COLUMN_NAME, utf8, COLUMN_DATA, (gpointer) fe, COLUMN_ICON, pix1, COLUMN_EDIT, FALSE, -1); ticonv_utf8_free(utf8); } for (j = 0; j < (int)g_node_n_children(parent); j++) { GNode *node = g_node_nth_child(parent, j); gchar **row_text = g_malloc0((CTREE_NCOLS + 1) * sizeof(gchar *)); VarEntry *ve = (VarEntry *) (node->data); char icon_name[256]; char * utf8 = ticonv_varname_to_utf8(GFMFile.model, ve->name, ve->type); row_text[0] = g_strdup(utf8); ticonv_utf8_free(utf8); row_text[2] = g_strdup_printf("%s", tifiles_vartype2string(GFMFile.model, ve->type)); tilp_var_get_size(ve, &row_text[3]); strcpy(icon_name, tifiles_vartype2icon(GFMFile.model, ve->type)); strcat(icon_name, ".ico"); tilp_file_underscorize(icon_name); pix9 = create_pixbuf(icon_name); // ticonv wrapper tilp_vars_translate(row_text[0]); gtk_tree_store_append(tree, &child_node, &pareng_node); gtk_tree_store_set(tree, &child_node, COLUMN_NAME, row_text[0], COLUMN_TYPE, row_text[2], COLUMN_SIZE, row_text[3], COLUMN_DATA, (gpointer) ve, COLUMN_ICON, pix9, COLUMN_FONT, FONT_NAME, COLUMN_EDIT, TRUE, -1); switch (ve->attr) { case ATTRB_NONE: gtk_tree_store_set(tree, &child_node, COLUMN_ATTR, pix7, -1); break; case ATTRB_LOCKED: gtk_tree_store_set(tree, &child_node, COLUMN_ATTR, pix4, -1); break; case ATTRB_ARCHIVED: gtk_tree_store_set(tree, &child_node, COLUMN_ATTR, pix5, -1); break; default: break; } g_object_unref(pix9); g_strfreev(row_text); } } // appplications tree apps = GFMFile.trees.apps; for (i = 0; i < (int)g_node_n_children(apps) && tifiles_is_flash(GFMFile.model); i++) { GNode *parent = g_node_nth_child(apps, i); for (j = 0; j < (int)g_node_n_children(parent); j++) { GNode *node = g_node_nth_child(parent, j); gchar **row_text = g_malloc0((CTREE_NCOLS + 1) * sizeof(gchar *)); VarEntry *ve = (VarEntry *) (node->data); char icon_name[256]; char * utf8 = ticonv_varname_to_utf8(GFMFile.model, ve->name, ve->type); row_text[0] = g_strdup(utf8); ticonv_utf8_free(utf8); row_text[2] = g_strdup_printf("%s", tifiles_vartype2string(GFMFile.model, ve->type)); row_text[3] = g_strdup_printf("%u", (int) (ve->size)); strcpy(icon_name, tifiles_vartype2icon(GFMFile.model, ve->type)); strcat(icon_name, ".ico"); tilp_file_underscorize(icon_name); pix9 = create_pixbuf(icon_name); gtk_tree_store_append(tree, &child_node, &apps_node); gtk_tree_store_set(tree, &child_node, COLUMN_NAME, row_text[0], COLUMN_TYPE, row_text[2], COLUMN_SIZE, row_text[3], COLUMN_DATA, (gpointer) ve, COLUMN_ICON, pix9, COLUMN_FONT, FONT_NAME, -1); g_object_unref(pix9); g_strfreev(row_text); } } gtk_tree_view_expand_all(GTK_TREE_VIEW(gfm_widget.tree)); g_object_unref(pix1); g_object_unref(pix2); g_object_unref(pix3); g_object_unref(pix4); g_object_unref(pix5); g_object_unref(pix6); }
void linphone_gtk_call_log_update(GtkWidget *w){ GtkTreeView *v=GTK_TREE_VIEW(linphone_gtk_get_widget(w,"logs_view")); GtkTreeStore *store; const MSList *logs; GtkTreeSelection *select; GtkWidget *notebook=linphone_gtk_get_widget(w,"viewswitch"); gint nb; store=(GtkTreeStore*)gtk_tree_view_get_model(v); if (store==NULL){ store=gtk_tree_store_new(3,GDK_TYPE_PIXBUF,G_TYPE_STRING,G_TYPE_POINTER,G_TYPE_STRING); gtk_tree_view_set_model(v,GTK_TREE_MODEL(store)); g_object_unref(G_OBJECT(store)); fill_renderers(GTK_TREE_VIEW(linphone_gtk_get_widget(w,"logs_view"))); select=gtk_tree_view_get_selection(v); gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE); g_signal_connect_swapped(G_OBJECT(select),"changed",(GCallback)call_log_selection_changed,v); g_signal_connect(G_OBJECT(notebook),"focus-tab",(GCallback)linphone_gtk_call_log_reset_missed_call,NULL); g_signal_connect(G_OBJECT(v),"button-press-event",(GCallback)linphone_gtk_call_log_button_pressed,NULL); // gtk_button_set_image(GTK_BUTTON(linphone_gtk_get_widget(w,"call_back_button")), // create_pixmap (linphone_gtk_get_ui_config("callback_button","status-green.png"))); } nb=linphone_core_get_missed_calls_count(linphone_gtk_get_core()); if(nb > 0) linphone_gtk_call_log_display_missed_call(nb); gtk_tree_store_clear (store); for (logs=linphone_core_get_call_logs(linphone_gtk_get_core());logs!=NULL;logs=logs->next){ LinphoneCallLog *cl=(LinphoneCallLog*)logs->data; GtkTreeIter iter, iter2; LinphoneAddress *la=linphone_call_log_get_dir(cl)==LinphoneCallIncoming ? linphone_call_log_get_from(cl) : linphone_call_log_get_to(cl); char *addr= linphone_address_as_string(la); const char *display; gchar *logtxt, *headtxt, *minutes, *seconds; gchar quality[20]; const char *status=NULL; gchar *start_date=NULL; LinphoneFriend *lf=NULL; int duration=linphone_call_log_get_duration(cl); time_t start_date_time=linphone_call_log_get_start_date(cl); #if GLIB_CHECK_VERSION(2,26,0) if (start_date_time){ GDateTime *dt=g_date_time_new_from_unix_local(start_date_time); start_date=g_date_time_format(dt,"%c"); g_date_time_unref(dt); } #else start_date=g_strdup(ctime(&start_date_time)); #endif lf=linphone_core_get_friend_by_address(linphone_gtk_get_core(),addr); if(lf != NULL){ display=linphone_address_get_display_name(linphone_friend_get_address(lf)); } else { display=linphone_address_get_display_name(la); } if (display==NULL){ display=linphone_address_get_username (la); if (display==NULL){ display=linphone_address_get_domain (la); } } else { linphone_address_set_display_name(la,display); } if (linphone_call_log_get_quality(cl)!=-1){ snprintf(quality,sizeof(quality),"%.1f",linphone_call_log_get_quality(cl)); }else snprintf(quality,sizeof(quality)-1,"%s",_("n/a")); switch(linphone_call_log_get_status(cl)){ case LinphoneCallAborted: status=_("Aborted"); break; case LinphoneCallMissed: status=_("Missed"); break; case LinphoneCallDeclined: status=_("Declined"); break; default: break; } minutes=g_markup_printf_escaped( ngettext("%i minute", "%i minutes", duration/60), duration/60); seconds=g_markup_printf_escaped( ngettext("%i second", "%i seconds", duration%60), duration%60); if (status==NULL) { headtxt=g_markup_printf_escaped(_("<big><b>%s</b></big>\t%s"),display,start_date ? start_date : ""); logtxt=g_markup_printf_escaped( _("<small><i>%s</i>\t" "<i>Quality: %s</i></small>\n%s\t%s\t"), addr, quality, minutes, seconds); } else { headtxt=g_markup_printf_escaped(_("<big><b>%s</b></big>\t%s"),display,start_date ? start_date : ""); logtxt=g_markup_printf_escaped( _("<small><i>%s</i></small>\t" "\n%s"),addr, status); } g_free(minutes); g_free(seconds); if (start_date) g_free(start_date); gtk_tree_store_append (store,&iter,NULL); GdkPixbuf *incoming = create_pixbuf("call_status_incoming.png"); GdkPixbuf *outgoing = create_pixbuf("call_status_outgoing.png"); gtk_tree_store_set (store,&iter, 0, linphone_call_log_get_dir(cl)==LinphoneCallOutgoing ? outgoing : incoming, 1, headtxt,2,cl,-1); gtk_tree_store_append (store,&iter2,&iter); gtk_tree_store_set (store,&iter2,1,logtxt,-1); ms_free(addr); g_free(logtxt); g_free(headtxt); } }
static GtkWidget * create_tree (void) { GtkTreeSelection *selection; GtkCellRenderer *cell; GtkWidget *tree_view; GtkTreeViewColumn *column; GtkTreeStore *model; GtkTreeIter iter; GtkWidget *box, *label, *scrolled_window; Demo *d = gtk_demos; model = gtk_tree_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT); tree_view = gtk_tree_view_new (); gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (model)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)); gtk_tree_selection_set_mode (GTK_TREE_SELECTION (selection), GTK_SELECTION_BROWSE); gtk_widget_set_size_request (tree_view, 200, -1); /* this code only supports 1 level of children. If we * want more we probably have to use a recursing function. */ while (d->title) { Demo *children = d->children; gtk_tree_store_append (GTK_TREE_STORE (model), &iter, NULL); gtk_tree_store_set (GTK_TREE_STORE (model), &iter, NAME_COLUMN, d->name, TITLE_COLUMN, d->title, FILENAME_COLUMN, d->filename, FUNC_COLUMN, d->func, STYLE_COLUMN, PANGO_STYLE_NORMAL, -1); d++; if (!children) continue; while (children->title) { GtkTreeIter child_iter; gtk_tree_store_append (GTK_TREE_STORE (model), &child_iter, &iter); gtk_tree_store_set (GTK_TREE_STORE (model), &child_iter, NAME_COLUMN, children->name, TITLE_COLUMN, children->title, FILENAME_COLUMN, children->filename, FUNC_COLUMN, children->func, STYLE_COLUMN, PANGO_STYLE_NORMAL, -1); children++; } } cell = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Widget (double click for demo)", cell, "text", TITLE_COLUMN, "style", STYLE_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), GTK_TREE_VIEW_COLUMN (column)); gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter); gtk_tree_selection_select_iter (GTK_TREE_SELECTION (selection), &iter); g_signal_connect (selection, "changed", G_CALLBACK (selection_cb), model); g_signal_connect (tree_view, "row_activated", G_CALLBACK (row_activated_cb), model); gtk_tree_view_collapse_all (GTK_TREE_VIEW (tree_view)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view); label = gtk_label_new ("Widget (double click for demo)"); box = gtk_notebook_new (); gtk_notebook_append_page (GTK_NOTEBOOK (box), scrolled_window, label); gtk_widget_grab_focus (tree_view); g_object_unref (model); return box; }
static GtkTreeModel * simple_tree_model (void) { GtkTreeIter iter, parent, child; GtkTreeStore *store = gtk_tree_store_new (N_SIMPLE_COLUMNS, G_TYPE_STRING, /* name text */ G_TYPE_STRING, /* icon name */ G_TYPE_STRING); /* description text */ gtk_tree_store_append (store, &parent, NULL); gtk_tree_store_set (store, &parent, SIMPLE_COLUMN_NAME, "Alice in wonderland", SIMPLE_COLUMN_ICON, "gtk-execute", SIMPLE_COLUMN_DESCRIPTION, "Twas brillig, and the slithy toves " "did gyre and gimble in the wabe", -1); gtk_tree_store_append (store, &iter, &parent); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Go ask", SIMPLE_COLUMN_ICON, "gtk-zoom-out", SIMPLE_COLUMN_DESCRIPTION, "One pill makes you shorter", -1); gtk_tree_store_append (store, &iter, &parent); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Alice", SIMPLE_COLUMN_ICON, "gtk-zoom-in", SIMPLE_COLUMN_DESCRIPTION, "Another one makes you tall", -1); gtk_tree_store_append (store, &iter, &parent); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Jefferson Airplane", SIMPLE_COLUMN_ICON, "gtk-zoom-fit", SIMPLE_COLUMN_DESCRIPTION, "The one's that mother gives you dont do anything at all", -1); gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Marry Poppins", SIMPLE_COLUMN_ICON, "gtk-yes", SIMPLE_COLUMN_DESCRIPTION, "Supercalifragilisticexpialidocious", -1); gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "George Bush", SIMPLE_COLUMN_ICON, "gtk-dialog-question", SIMPLE_COLUMN_DESCRIPTION, "It's a very good question, very direct, " "and I'm not going to answer it", -1); gtk_tree_store_append (store, &parent, NULL); gtk_tree_store_set (store, &parent, SIMPLE_COLUMN_NAME, "Whinnie the pooh", SIMPLE_COLUMN_ICON, "gtk-stop", SIMPLE_COLUMN_DESCRIPTION, "The most wonderful thing about tiggers, " "is tiggers are wonderful things", -1); gtk_tree_store_append (store, &iter, &parent); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Tigger", SIMPLE_COLUMN_ICON, "gtk-yes", SIMPLE_COLUMN_DESCRIPTION, "Eager", -1); gtk_tree_store_append (store, &child, &iter); gtk_tree_store_set (store, &child, SIMPLE_COLUMN_NAME, "Jump", SIMPLE_COLUMN_ICON, "gtk-yes", SIMPLE_COLUMN_DESCRIPTION, "Very High", -1); gtk_tree_store_append (store, &child, &iter); gtk_tree_store_set (store, &child, SIMPLE_COLUMN_NAME, "Pounce", SIMPLE_COLUMN_ICON, "gtk-no", SIMPLE_COLUMN_DESCRIPTION, "On Pooh", -1); gtk_tree_store_append (store, &child, &iter); gtk_tree_store_set (store, &child, SIMPLE_COLUMN_NAME, "Bounce", SIMPLE_COLUMN_ICON, "gtk-cancel", SIMPLE_COLUMN_DESCRIPTION, "Around", -1); gtk_tree_store_append (store, &iter, &parent); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Owl", SIMPLE_COLUMN_ICON, "gtk-stop", SIMPLE_COLUMN_DESCRIPTION, "Wise", -1); gtk_tree_store_append (store, &iter, &parent); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Eor", SIMPLE_COLUMN_ICON, "gtk-no", SIMPLE_COLUMN_DESCRIPTION, "Depressed", -1); gtk_tree_store_append (store, &iter, &parent); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Piglet", SIMPLE_COLUMN_ICON, "gtk-media-play", SIMPLE_COLUMN_DESCRIPTION, "Insecure", -1); gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Aleister Crowley", SIMPLE_COLUMN_ICON, "gtk-about", SIMPLE_COLUMN_DESCRIPTION, "Thou shalt do what thou wilt shall be the whole of the law", -1); gtk_tree_store_append (store, &iter, NULL); gtk_tree_store_set (store, &iter, SIMPLE_COLUMN_NAME, "Mark Twain", SIMPLE_COLUMN_ICON, "gtk-quit", SIMPLE_COLUMN_DESCRIPTION, "Giving up smoking is the easiest thing in the world. " "I know because I've done it thousands of times.", -1); return (GtkTreeModel *)store; }