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;
}
