/**
* ticalcs_dirlist_ve_count:
* @tree: a tree (var or app).
*
* Count how many entries (vars or apps) are listed in the tree.
*
* Return value: the number of entries.
**/
TIEXPORT3 int TICALL ticalcs_dirlist_ve_count(GNode* tree)
{
int i, j;
GNode *vars = tree;
int nvars = 0;
TreeInfo *info;
if (tree == NULL)
{
ticalcs_critical("ticalcs_dirlist_ve_count(NULL)");
return 0;
}
info = (TreeInfo *)(tree->data);
if (info == NULL)
return 0;
if (strcmp(info->type, VAR_NODE_NAME) && strcmp(info->type, APP_NODE_NAME))
return 0;
for (i = 0; i < (int)g_node_n_children(vars); i++) // parse folders
{
GNode *parent = g_node_nth_child(vars, i);
for (j = 0; j < (int)g_node_n_children(parent); j++) //parse variables
nvars++;
}
return nvars;
}
/**
* ticalcs_dirlist_flash_used:
* @tree: a tree (app only).
*
* Count how much memory is used by archived variables and apps listed in the trees.
*
* Return value: size of all FLASH in bytes.
**/
TIEXPORT3 int TICALL ticalcs_dirlist_flash_used(GNode* vars, GNode* apps)
{
int i, j;
uint32_t mem = 0;
TreeInfo *info1;
TreeInfo *info2;
if (vars == NULL || apps == NULL)
{
ticalcs_critical("ticalcs_dirlist_flash_used: an argument is NULL");
return 0;
}
info1 = (TreeInfo *)(vars->data);
info2 = (TreeInfo *)(apps->data);
if (info1 == NULL || info2 == NULL)
{
return 0;
}
if (!strcmp(info1->type, VAR_NODE_NAME))
{
for (i = 0; i < (int)g_node_n_children(vars); i++) // parse folders
{
GNode *parent = g_node_nth_child(vars, i);
for (j = 0; j < (int)g_node_n_children(parent); j++) //parse variables
{
GNode *child = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (child->data);
if (ve->attr == ATTRB_ARCHIVED)
{
mem += ve->size;
}
}
}
}
if (!strcmp(info2->type, APP_NODE_NAME))
{
for (i = 0; i < (int)g_node_n_children(apps); i++)
{
GNode *parent = g_node_nth_child(apps, i);
for (j = 0; j < (int)g_node_n_children(parent); j++) //parse apps
{
GNode *child = g_node_nth_child(parent, i);
VarEntry *ve = (VarEntry *) (child->data);
mem += ve->size;
}
}
}
return mem;
}
/**
* ticalcs_dirlist_ve_exist:
* @tree: the tree to parse.
* @s: the full name of the variable or application to search for.
*
* Parse the tree for the given varname & folder or appname.
*
* Return value: a pointer on the #VarEntry found or NULL if not found.
**/
TIEXPORT3 VarEntry *TICALL ticalcs_dirlist_ve_exist(GNode* tree, VarEntry *s)
{
int i, j;
GNode *vars = tree;
TreeInfo *info;
if (tree == NULL || s == NULL)
{
ticalcs_critical("ticalcs_dirlist_ve_exist: an argument is NULL");
return NULL;
}
info = (TreeInfo *)(tree->data);
if (info == NULL)
{
return NULL;
}
if (strcmp(info->type, VAR_NODE_NAME) && strcmp(info->type, APP_NODE_NAME))
{
return NULL;
}
for (i = 0; i < (int)g_node_n_children(vars); i++) // parse folders
{
GNode *parent = g_node_nth_child(vars, i);
VarEntry *fe = (VarEntry *) (parent->data);
if ((fe != NULL) && strcmp(fe->name, s->folder))
{
continue;
}
for (j = 0; j < (int)g_node_n_children(parent); j++) //parse variables
{
GNode *child = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (child->data);
if ( !strcmp(ve->name, s->name)
&& ( !((info->model >= CALC_TI73 && info->model <= CALC_TI84P)
|| info->model == CALC_TI84P_USB || info->model == CALC_TI83PCE_USB
|| info->model == CALC_TI84PCE_USB || info->model == CALC_TI82A_USB)
|| info->model == CALC_TI84PT_USB || (ve->type == s->type)))
{
return ve;
}
}
}
return NULL;
}
static void ctree_populate(GtkWidget *widget)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreeModel *model = gtk_tree_view_get_model(view);
GtkTreeStore *store = GTK_TREE_STORE(model);
gint i, j;
GNode *tree;
uint16_t handle;
// Parse VAT
vat_parse(&tree);
// Retrieve breakpoint
if(ti68k_bkpt_get_pgmentry(0, &handle))
handle = -1;
// and show it
for (i = 0; i < (int)g_node_n_children(tree); i++)
{
GNode *fol_node = g_node_nth_child(tree, i);
VatSymEntry *vse = (VatSymEntry *)fol_node->data;
GtkTreeIter fol_iter;
gtk_tree_store_append(store, &fol_iter, NULL);
gtk_tree_store_set(store, &fol_iter,
COL_NAME, vse->name, COL_HANDLE, vse->handle,
COL_CHECK, FALSE, COL_VISIBLE, FALSE,
-1);
for(j = 0; j < (int)g_node_n_children(fol_node); j++)
{
GNode *var_node = g_node_nth_child(fol_node, j);
VatSymEntry *vse = (VatSymEntry *)var_node->data;
GtkTreeIter var_iter;
gtk_tree_store_append(store, &var_iter, &fol_iter);
gtk_tree_store_set(store, &var_iter,
COL_NAME, vse->name, COL_HANDLE, vse->handle,
COL_CHECK, (vse->handle == handle), COL_VISIBLE, TRUE,
-1);
}
}
gtk_tree_view_expand_all(view);
// Free copy of VAT
vat_free(&tree);
}
static GnomeVFSResult
do_remove_directory (GnomeVFSMethod *method,
GnomeVFSURI *uri,
GnomeVFSContext *context)
{
FakeNode *file;
g_print ("do_remove_directory ('%s')\n", uri->text);
file = get_fake_node_from_uri (uri);
if (!file) {
return GNOME_VFS_ERROR_INVALID_URI;
}
/* Can't remove the root. */
if (file->gnode == root) {
return GNOME_VFS_ERROR_NOT_PERMITTED;
}
/* Can't remove non-empty directories. */
if (g_node_n_children (file->gnode) > 0) {
return GNOME_VFS_ERROR_NOT_PERMITTED;
}
return remove_fake_node_by_uri (uri);
}
void
i7_node_layout(I7Node *self, GooCanvasItemModel *skein, GooCanvas *canvas, gdouble x)
{
I7_NODE_USE_PRIVATE;
gdouble hspacing, vspacing;
g_object_get(skein,
"horizontal-spacing", &hspacing,
"vertical-spacing", &vspacing,
NULL);
if(g_node_n_children(self->gnode) == 1)
i7_node_layout(self->gnode->children->data, skein, canvas, x);
else {
/* Find the total width of all descendant nodes */
gdouble total = i7_node_get_tree_width(self, skein, canvas);
/* Lay out each child node */
GNode *child;
gdouble child_x = 0.0;
for(child = self->gnode->children; child; child = child->next) {
gdouble treewidth = i7_node_get_tree_width(child->data, skein, canvas);
i7_node_layout(child->data, skein, canvas, x - total * 0.5 + child_x + treewidth * 0.5);
child_x += treewidth + hspacing;
}
}
/* Move the node's group to its proper place */
gdouble y = (gdouble)(g_node_depth(self->gnode) - 1.0) * vspacing;
g_object_set(self, "x", x, "y", y, NULL);
/* Cache the x coordinate */
priv->x = x;
}
static gboolean cloud_config_simplify(GNode *node, __unused__ gpointer data) {
if (node->data) {
return false;
}
GNode *child = g_node_last_child(node);
while (child) {
if (child->data) {
child = g_node_prev_sibling(child);
continue;
}
GNode *remove = child;
child = g_node_prev_sibling(child);
g_node_append(node->parent, g_node_copy(remove));
g_node_unlink(remove);
g_node_destroy(remove);
}
if (g_node_n_children(node) == 0) {
g_node_unlink(node);
g_node_destroy(node);
}
return false;
}
/*
* Mark children as invisible, if needed.
*/
static void gopt_set_children_visible(struct gopt_job_view *gjv,
struct fio_option *parent,
gboolean visible)
{
GNode *child, *node;
if (parent->hide_on_set)
visible = !visible;
node = g_node_find(gopt_dep_tree, G_IN_ORDER, G_TRAVERSE_ALL, parent);
child = g_node_first_child(node);
while (child) {
struct fio_option *o = child->data;
struct gopt *g = o->gui_data;
GtkWidget *widget = g->box;
/*
* Recurse into child, if it also has children
*/
if (g_node_n_children(child))
gopt_set_children_visible(gjv, o, visible);
gtk_widget_set_sensitive(widget, visible);
child = g_node_next_sibling(child);
}
}
static void cloud_config_process(GNode *userdata, GList *handlers) {
/* toplevel node is always a sequence, so skip over that sequence */
userdata = g_node_first_child(userdata);
/* loop over all toplevel elements and find modules to handle them */
for (guint i = 0; i < g_node_n_children(userdata); i++) {
GNode *node = g_node_nth_child(userdata, i);
struct cc_module_handler_struct* h;
bool found = false;
for (guint j = 0; j < g_list_length(handlers); j++) {
h = g_list_nth_data(handlers, j);
if (g_strcmp0(h->name, node->data) == 0) {
found = true;
break;
}
}
if (found) {
LOG("Executing handler for block \"%s\"\n", (char*)node->data);
h->handler(node);
} else {
LOG("No handler found for block \"%s\"\n", (char*)node->data);
}
}
}
/**
* ticalcs_dirlist_ram_used:
* @tree: a tree (var only).
*
* Count how much memory is used by variables listed in the tree.
*
* Return value: size of all variables in bytes.
**/
TIEXPORT3 int TICALL ticalcs_dirlist_ram_used(GNode* tree)
{
int i, j;
GNode *vars = tree;
uint32_t mem = 0;
TreeInfo *info;
if (tree == NULL)
{
ticalcs_critical("ticalcs_dirlist_ram_used(NULL)");
return 0;
}
info = (TreeInfo *)(tree->data);
if (info == NULL)
{
return 0;
}
if (strcmp(info->type, VAR_NODE_NAME))
{
return 0;
}
for (i = 0; i < (int)g_node_n_children(vars); i++) // parse folders
{
GNode *parent = g_node_nth_child(vars, i);
for (j = 0; j < (int)g_node_n_children(parent); j++) //parse variables
{
GNode *child = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (child->data);
if (ve->attr != ATTRB_ARCHIVED)
{
mem += ve->size;
}
}
}
return mem;
}
static void display_tree(TreeInfo * info, GNode * vars)
{
int i;
//ticalcs_info("vars has %d children", (int)g_node_n_children(vars));
for (i = 0; i < (int)g_node_n_children(vars); i++) // parse children
{
GNode *parent = g_node_nth_child(vars, i);
VarEntry *fe = (VarEntry *) (parent->data);
int j;
if (fe != NULL)
{
display_node(info, fe, -1);
}
//ticalcs_info("parent has %d children", (int)g_node_n_children(parent));
if (info->model != CALC_NSPIRE)
{
for (j = 0; j < (int)g_node_n_children(parent); j++)
{
GNode *child = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (child->data);
display_node(info, ve, ve->type);
}
}
else
{
// Recurse into sub-folder if necessary.
if (fe != NULL && fe->type == NSP_DIR)
{
//ticalcs_info("Recurse");
display_tree(info, parent);
}
}
//ticalcs_info("finished enumerating %d children of parent", (int)g_node_n_children(parent));
}
//ticalcs_info("finished enumerating %d children of vars", (int)g_node_n_children(vars));
}
/*
* i7_node_get_next_difference:
* @node: reference node to get next difference from
*
* Finds the next difference (either below @node, or to the right in the skein).
* Returns: pointer to next different node.
*/
I7Node *
i7_node_get_next_difference(I7Node *node)
{
I7Node *diff_below;
if((diff_below = i7_node_get_next_difference_below(node)) != NULL)
return diff_below;
/* Iterate up from this point */
GNode *top, *our_branch;
top = node->gnode;
while(top) {
our_branch = top;
top = top->parent;
while(top && g_node_n_children(top) <= 1) {
our_branch = top;
top = top->parent;
}
if(!top)
return NULL;
/* Find the item to the right */
gboolean found_branch = FALSE;
GNode *child = top->children;
do {
if(child == our_branch) {
found_branch = TRUE;
break;
}
} while((child = child->next));
if(!found_branch)
return FALSE;
/* See if we can find any differences there */
while((child = child->next)) {
I7Node *child_node = I7_NODE(child->data);
if(i7_node_get_different(child_node))
return child_node;
I7Node *child_diff = i7_node_get_next_difference_below(child_node);
if(child_diff)
return child_diff;
}
}
return NULL;
}
static gboolean pgpmime_is_encrypted(MimeInfo *mimeinfo)
{
MimeInfo *tmpinfo;
const gchar *tmpstr;
const gchar *begin_indicator = "-----BEGIN PGP MESSAGE-----";
const gchar *end_indicator = "-----END PGP MESSAGE-----";
gchar *textdata;
if (mimeinfo->type != MIMETYPE_MULTIPART)
return FALSE;
if (g_ascii_strcasecmp(mimeinfo->subtype, "encrypted"))
return FALSE;
tmpstr = procmime_mimeinfo_get_parameter(mimeinfo, "protocol");
if ((tmpstr == NULL) || g_ascii_strcasecmp(tmpstr, "application/pgp-encrypted"))
return FALSE;
if (g_node_n_children(mimeinfo->node) != 2)
return FALSE;
tmpinfo = (MimeInfo *) g_node_nth_child(mimeinfo->node, 0)->data;
if (tmpinfo->type != MIMETYPE_APPLICATION)
return FALSE;
if (g_ascii_strcasecmp(tmpinfo->subtype, "pgp-encrypted"))
return FALSE;
tmpinfo = (MimeInfo *) g_node_nth_child(mimeinfo->node, 1)->data;
if (tmpinfo->type != MIMETYPE_APPLICATION)
return FALSE;
if (g_ascii_strcasecmp(tmpinfo->subtype, "octet-stream"))
return FALSE;
textdata = get_part_as_string(tmpinfo);
if (!textdata)
return FALSE;
if (!pgp_locate_armor_header(textdata, begin_indicator)) {
g_free(textdata);
return FALSE;
}
if (!pgp_locate_armor_header(textdata, end_indicator)) {
g_free(textdata);
return FALSE;
}
g_free(textdata);
return TRUE;
}
void
glade_model_data_reorder_column (GNode * node, gint column, gint nth)
{
GNode *row, *item;
g_return_if_fail (node != NULL);
for (row = node->children; row; row = row->next)
{
g_return_if_fail (nth >= 0 && nth < g_node_n_children (row));
item = g_node_nth_child (row, column);
g_node_unlink (item);
g_node_insert (row, nth, item);
}
}
void
glade_model_data_insert_column (GNode * node,
GType type, const gchar * column_name, gint nth)
{
GNode *row, *item;
GladeModelData *data;
g_return_if_fail (node != NULL);
for (row = node->children; row; row = row->next)
{
g_return_if_fail (nth >= 0 && nth <= g_node_n_children (row));
data = glade_model_data_new (type, column_name);
item = g_node_new (data);
g_node_insert (row, nth, item);
}
}
static void write_dict(GByteArray * bplist, GNode * node, GHashTable * ref_table, uint8_t dict_param_size)
{
uint64_t idx1 = 0;
uint64_t idx2 = 0;
uint8_t *buff = NULL;
GNode *cur = NULL;
uint64_t i = 0;
uint64_t size = g_node_n_children(node) / 2;
uint8_t marker = BPLIST_DICT | (size < 15 ? size : 0xf);
g_byte_array_append(bplist, &marker, sizeof(uint8_t));
if (size >= 15)
{
GByteArray *int_buff = g_byte_array_new();
write_int(int_buff, size);
g_byte_array_append(bplist, int_buff->data, int_buff->len);
g_byte_array_free(int_buff, TRUE);
}
buff = (uint8_t *) malloc(size * 2 * dict_param_size);
for (i = 0, cur = node->children; cur && i < size; cur = cur->next->next, i++)
{
idx1 = *(uint64_t *) (g_hash_table_lookup(ref_table, cur));
#if G_BYTE_ORDER == G_BIG_ENDIAN
idx1 = idx1 << ((sizeof(uint64_t) - dict_param_size) * 8);
#endif
memcpy(buff + i * dict_param_size, &idx1, dict_param_size);
byte_convert(buff + i * dict_param_size, dict_param_size);
idx2 = *(uint64_t *) (g_hash_table_lookup(ref_table, cur->next));
#if G_BYTE_ORDER == G_BIG_ENDIAN
idx2 = idx2 << ((sizeof(uint64_t) - dict_param_size) * 8);
#endif
memcpy(buff + (i + size) * dict_param_size, &idx2, dict_param_size);
byte_convert(buff + (i + size) * dict_param_size, dict_param_size);
}
//now append to bplist
g_byte_array_append(bplist, buff, size * 2 * dict_param_size);
free(buff);
}
void
glade_model_data_remove_column (GNode * node, gint nth)
{
GNode *row, *item;
GladeModelData *data;
g_return_if_fail (node != NULL);
for (row = node->children; row; row = row->next)
{
g_return_if_fail (nth >= 0 && nth < g_node_n_children (row));
item = g_node_nth_child (row, nth);
data = item->data;
glade_model_data_free (data);
g_node_destroy (item);
}
}
/**
* Gets a flat collection of nodes, sorted by priority
**/
GNode*
get_transactions(GNode *config, boolean priority_mode)
{
d_dplog("commit2::get_transactions()");
if (config == NULL) {
return NULL;
}
gpointer gp = ((GNode*)config)->data;
GNode *trans_root = g_node_new(gp);
if (priority_mode) {
g_node_traverse(config,
G_POST_ORDER,
G_TRAVERSE_ALL,
-1,
(GNodeTraverseFunc)sort_func_priority,
(gpointer)trans_root);
//only do this if the root isn't empty
if (g_node_n_children(config) != 0) {
g_node_insert(trans_root,-1,config); //add what's left
}
//now need pass to handle extended priority system
g_node_traverse(trans_root,
G_POST_ORDER,
G_TRAVERSE_ALL,
-1,
(GNodeTraverseFunc)sort_func_priority_extended,
(gpointer)trans_root);
}
else {
g_node_traverse(config,
G_IN_ORDER,
G_TRAVERSE_ALL,
-1,
(GNodeTraverseFunc)sort_func_simple,
(gpointer)trans_root);
}
return trans_root;
}
gdouble
i7_node_get_tree_width(I7Node *self, GooCanvasItemModel *skein, GooCanvas *canvas)
{
I7_NODE_USE_PRIVATE;
gdouble spacing;
g_object_get(skein, "horizontal-spacing", &spacing, NULL);
/* Get the tree width of all children */
unsigned i;
gdouble total = 0.0;
for(i = 0; i < g_node_n_children(self->gnode); i++) {
total += i7_node_get_tree_width(g_node_nth_child(self->gnode, i)->data, skein, canvas);
if(i > 0)
total += spacing;
}
/* Return whichever is larger, that or the node width */
if(priv->command_width < 0.0)
i7_node_calculate_size(self, skein, canvas);
gdouble width = MAX(priv->command_width, priv->label_width);
return MAX(total, width);
}
/**
* ticalcs_dirlist_display:
* @tree: the tree to display.
*
* Display to stdout the tree content formatted in a tab.
*
* Return value: none.
**/
TIEXPORT3 void TICALL ticalcs_dirlist_display(GNode* tree)
{
GNode *vars = tree;
TreeInfo *info;
int i;
if (tree == NULL)
{
ticalcs_critical("ticalcs_dirlist_display(NULL)");
return;
}
info = (TreeInfo *)(tree->data);
if (info == NULL)
{
return;
}
printf( "+------------------+----------+----+----+----------+----------+\n");
printf(_("| B. name | T. name |Attr|Type| Size | Folder |\n"));
printf( "+------------------+----------+----+----+----------+----------+\n");
i = (int)g_node_n_children(vars);
//ticalcs_info("Root has %d children", i);
display_tree(info, vars);
if (!i)
{
if (!strcmp(info->type, VAR_NODE_NAME))
{
printf(_("| No variables |\n"));
}
else if (!strcmp(info->type, APP_NODE_NAME))
{
printf(_("| No applications |\n"));
}
}
printf(_("+------------------+----------+----+----+----------+----------+"));
printf("\n");
}
// Helper function for get_dirlist, it does the bulk of the work.
static int enumerate_folder(CalcHandle* handle, GNode** vars, const char * folder_name)
{
int ret;
ticalcs_info("enumerate_folder<%s>\n", folder_name);
do
{
char varname[VARNAME_MAX];
ret = nsp_cmd_s_dir_enum_init(handle, folder_name);
if (ret)
{
break;
}
ret = nsp_cmd_r_dir_enum_init(handle);
if (ret)
{
break;
}
for (;;)
{
VarEntry *fe;
GNode *node;
char *ext;
uint32_t varsize;
uint8_t vartype;
ret = nsp_cmd_s_dir_enum_next(handle);
if (ret)
{
break;
}
ret = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype);
if (ret == ERR_EOT)
{
ret = 0;
break;
}
else if (ret != 0)
{
break;
}
fe = tifiles_ve_create();
ticalcs_strlcpy(fe->folder, folder_name + 1, sizeof(fe->folder)); // Skip leading /
fe->size = varsize;
fe->type = vartype;
fe->attr = ATTRB_NONE;
ext = tifiles_fext_get(varname);
// Just a sanity check
if (ext)
{
// Did the file name have any non-empty extension ?
if (*ext)
{
// Do we know about this file type ?
if (fe->type < NSP_MAXTYPES)
{
// Then we can remove the exension.
*(ext-1) = '\0';
}
// else don't remove the extension.
}
// else there is no extension to remove.
}
ticalcs_strlcpy(fe->name, varname, sizeof(fe->name));
node = dirlist_create_append_node(fe, vars);
if (!node)
{
ret = ERR_MALLOC;
break;
}
ticalcs_info(_("Name: %s | Type: %8s | Attr: %i | Size: %08X"),
fe->name,
tifiles_vartype2string(handle->model, fe->type),
fe->attr,
fe->size);
}
while (!ret)
{
int i;
ret = nsp_cmd_s_dir_enum_done(handle);
if (ret)
{
break;
}
ret = nsp_cmd_r_dir_enum_done(handle);
if (ret)
{
break;
}
// Enumerate elements of root folder.
for (i = 0; i < (int)g_node_n_children(*vars); i++)
{
char new_folder_name[FLDNAME_MAX];
const char * separator_if_any;
GNode * folder = g_node_nth_child(*vars, i);
uint8_t vartype = ((VarEntry *)(folder->data))->type;
// Don't recurse into regular files (type 0, TNS or e.g. themes.csv on OS 3.0+).
if (vartype == 0)
{
ticalcs_info(_("Not enumerating documents in %s because it's not a folder\n"), ((VarEntry *)(folder->data))->name);
continue;
}
// Prevent names from starting with "//".
if (strcmp(folder_name, "/"))
{
separator_if_any = "/";
}
else
{
separator_if_any = "";
}
ticalcs_slprintf(new_folder_name, sizeof(new_folder_name), "%s%s%s", folder_name, separator_if_any, ((VarEntry *)(folder->data))->name);
ticalcs_info(_("Directory listing in <%s>...\n"), new_folder_name);
ret = enumerate_folder(handle, &folder, new_folder_name);
if (ret)
{
break;
}
}
break;
}
} while (0);
return ret;
}
/**
* ticalcs_dirlist_ve_del:
* @tree: source tree.
* @entry: entry to remove.
*
* Remove an entry into the main tree (if it doesn't exist yet).
*
* Return value: none.
**/
TIEXPORT3 void TICALL ticalcs_dirlist_ve_del(GNode* tree, VarEntry *entry)
{
TreeInfo *info;
int i, j;
int found = 0;
GNode *parent = NULL;
VarEntry *fe = NULL;
GNode *child = NULL;
VarEntry *ve;
const char *folder;
if (tree == NULL || entry == NULL)
{
ticalcs_critical("ticalcs_dirlist_ve_del: an argument is NULL");
return;
}
info = (TreeInfo *)(tree->data);
if (info == NULL)
{
return;
}
if (strcmp(info->type, VAR_NODE_NAME))
{
return;
}
if (!strcmp(entry->folder, "") && tifiles_has_folder(info->model))
{
folder = "main";
}
else
{
folder = entry->folder;
}
// Parse folders
for (found = 0, i = 0; i < (int)g_node_n_children(tree); i++)
{
parent = g_node_nth_child(tree, i);
fe = (VarEntry *) (parent->data);
if (fe == NULL)
{
break;
}
if (!strcmp(fe->name, folder))
{
found = !0;
break;
}
}
if (!found && fe)
{
return;
}
// next, delete variables beneath this folder
for (found = 0, j = 0; j < (int)g_node_n_children(parent); j++)
{
child = g_node_nth_child(parent, j);
ve = (VarEntry *) (child->data);
if (!strcmp(ve->name, entry->name))
{
found = !0;
break;
}
}
if (found)
{
tifiles_ve_delete(child->data);
g_node_destroy(child);
}
if (fe && found)
{
fe->size--;
}
}
/**
* ticalcs_dirlist_ve_add:
* @tree: source tree.
* @entry: entry to add.
*
* Add an entry into the main tree (if it doesn't exist yet).
*
* Return value: none.
**/
TIEXPORT3 void TICALL ticalcs_dirlist_ve_add(GNode* tree, VarEntry *entry)
{
TreeInfo *info;
int i, j;
int found = 0;
GNode *parent = NULL;
VarEntry *fe = NULL;
GNode *child;
VarEntry *ve;
const char *folder;
if (tree == NULL || entry == NULL)
{
ticalcs_critical("ticalcs_dirlist_ve_add: an argument is NULL");
return;
}
info = (TreeInfo *)(tree->data);
if (info == NULL)
{
return;
}
if (strcmp(info->type, VAR_NODE_NAME) && strcmp(info->type, APP_NODE_NAME))
{
return;
}
if (!strcmp(entry->folder, "") && tifiles_has_folder(info->model))
{
folder = "main";
}
else
{
folder = entry->folder;
}
// If TI8x tree is empty, create pseudo-folder (NULL)
if (!g_node_n_children(tree) && !tifiles_has_folder(info->model))
{
parent = g_node_new(NULL);
g_node_append(tree, parent);
}
// Check for one folder at least...
if (g_node_n_children(tree) > 0)
{
// Parse folders
for (found = 0, i = 0; i < (int)g_node_n_children(tree); i++)
{
parent = g_node_nth_child(tree, i);
fe = (VarEntry *) (parent->data);
if (fe == NULL)
{
break;
}
if (!strcmp(fe->name, folder))
{
found = !0;
break;
}
}
}
// folder doesn't exist? => create!
if ((!found && fe) ||
(!g_node_n_children(tree) && tifiles_has_folder(info->model)))
{
fe = tifiles_ve_create();
if (fe != NULL)
{
ticalcs_strlcpy(fe->name, entry->folder, sizeof(fe->name));
fe->type = TI89_DIR;
parent = g_node_new(fe);
g_node_append(tree, parent);
}
}
if (!strcmp(entry->name, ""))
{
return;
}
// next, add variables beneath this folder
for (found = 0, j = 0; j < (int)g_node_n_children(parent); j++)
{
child = g_node_nth_child(parent, j);
ve = (VarEntry *) (child->data);
if (!strcmp(ve->name, entry->name))
{
found = !0;
break;
}
}
if (!found)
{
ve = tifiles_ve_dup(entry);
if (ve != NULL)
{
child = g_node_new(ve);
g_node_append(parent, child);
}
}
if (fe && found)
{
fe->size++;
}
}
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);
}
static void rssyl_opml_export_func(FolderItem *item, gpointer data)
{
RSSylOpmlCtx *ctx = (RSSylOpmlCtx *)data;
RFolderItem *ritem = (RFolderItem *)item;
gboolean isfolder = FALSE, err = FALSE;
gboolean haschildren = FALSE;
gchar *indent = NULL, *xmlurl = NULL;
gchar *tmpoffn = NULL, *tmpurl = NULL, *tmpname = NULL;
gint depth;
if( !IS_RSSYL_FOLDER_ITEM(item) )
return;
if( folder_item_parent(item) == NULL )
return;
/* Check for depth and adjust indentation */
depth = rssyl_folder_depth(item);
if( depth < ctx->depth ) {
for( ctx->depth--; depth <= ctx->depth; ctx->depth-- ) {
indent = g_strnfill(ctx->depth + 1, '\t');
err |= (fprintf(ctx->f, "%s</outline>\n", indent) < 0);
g_free(indent);
}
}
ctx->depth = depth;
if( ritem->url == NULL ) {
isfolder = TRUE;
} else {
tmpurl = rssyl_strreplace(ritem->url, "&", "&");
xmlurl = g_strdup_printf("xmlUrl=\"%s\"", tmpurl);
g_free(tmpurl);
}
if( g_node_n_children(item->node) )
haschildren = TRUE;
indent = g_strnfill(ctx->depth + 1, '\t');
tmpname = rssyl_strreplace(item->name, "&", "&");
if( ritem->official_title != NULL )
tmpoffn = rssyl_strreplace(ritem->official_title, "&", "&");
else
tmpoffn = g_strdup(tmpname);
err |= (fprintf(ctx->f,
"%s<outline title=\"%s\" text=\"%s\" description=\"%s\" type=\"%s\" %s%s>\n",
indent, tmpname, tmpoffn, tmpoffn,
(isfolder ? "folder" : "rss"),
(xmlurl ? xmlurl : ""), (haschildren ? "" : "/")) < 0);
g_free(indent);
g_free(xmlurl);
g_free(tmpname);
g_free(tmpoffn);
if( err ) {
log_warning(LOG_PROTOCOL,
_("RSSyl: Error while writing '%s' to feed export list.\n"),
item->name);
debug_print("Error while writing '%s' to feed_export list.\n",
item->name);
}
}
void ctree_refresh(void)
{
GtkTreeView *view = GTK_TREE_VIEW(ctree_wnd);
GtkTreeViewColumn *col;
GdkPixbuf *pix1, *pix2, *pix3, *pix4, *pix5, *pix6;
GdkPixbuf *pix9 = NULL;
GtkTreeIter parent_node;
GtkTreeIter child_node;
GtkIconTheme *theme;
GNode *vars, *apps;
int i, j;
if (remote.var_tree == NULL)
return;
if(working_mode & MODE_CMD)
return;
// sort variables
for(i = 0; i < CTREE_NVCOLS; i++)
{
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_sort_indicator(col, FALSE);
}
switch (options.remote_sort)
{
case SORT_BY_NAME:
tilp_vars_sort_by_name();
col = gtk_tree_view_get_column(view, COLUMN_NAME);
gtk_tree_view_column_set_sort_indicator(col, TRUE);
gtk_tree_view_column_set_sort_order(col, options.remote_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
break;
case SORT_BY_INFO:
tilp_vars_sort_by_info();
col = gtk_tree_view_get_column(view, COLUMN_ATTR);
gtk_tree_view_column_set_sort_indicator(col, TRUE);
gtk_tree_view_column_set_sort_order(col, options.remote_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
break;
case SORT_BY_TYPE:
tilp_vars_sort_by_type();
col = gtk_tree_view_get_column(view, COLUMN_TYPE);
gtk_tree_view_column_set_sort_indicator(col, TRUE);
gtk_tree_view_column_set_sort_order(col, options.remote_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
break;
case SORT_BY_SIZE:
tilp_vars_sort_by_size();
col = gtk_tree_view_get_column(view, COLUMN_SIZE);
gtk_tree_view_column_set_sort_indicator(col, TRUE);
gtk_tree_view_column_set_sort_order(col, options.remote_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
break;
}
// place base nodes
ctree_set_basetree();
memcpy(&parent_node, &vars_node, sizeof(GtkTreeIter));
// load pixmaps
theme = gtk_icon_theme_get_default();
pix1 = gtk_widget_render_icon(GTK_WIDGET(view), GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL);
pix2 = create_pixbuf("TIicon2.ico");
pix3 = gtk_icon_theme_load_icon(theme, "folder-open", 16, 0, NULL);
if (pix3 == NULL)
{
pix3 = create_pixbuf("ctree_open_dir.png");
}
pix4 = gtk_icon_theme_load_icon(theme, "emblem-readonly", 16, 0, NULL);
if (pix4 == NULL)
{
pix4 = create_pixbuf("attr_locked.png");
}
pix5 = gtk_icon_theme_load_icon(theme, "emblem-system", 16, 0, NULL);
if (pix5 == NULL)
{
pix5 = create_pixbuf("attr_archived.png");
}
pix6 = create_pixbuf("TIicon4.ico");
// variables tree
vars = remote.var_tree;
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) || (ticalcs_calc_features(calc_handle) & FTS_FOLDER))
{
char *utf8 = ticonv_varname_to_utf8(options.calc_model, fe->name, -1);
gtk_tree_store_append(tree, &parent_node, &vars_node);
gtk_tree_store_set(tree, &parent_node,
COLUMN_NAME, utf8,
COLUMN_DATA, (gpointer) fe,
COLUMN_ICON, pix1, -1);
g_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];
row_text[0] = ticonv_varname_to_utf8(options.calc_model, ve->name, ve->type);
row_text[2] = g_strdup_printf("%s", tifiles_vartype2string(options.calc_model, ve->type));
tilp_var_get_size(ve, &row_text[3]);
strcpy(icon_name, tifiles_vartype2icon(options.calc_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, &parent_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);
switch (ve->attr)
{
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 = remote.app_tree;
for (i = 0; i < (int)g_node_n_children(apps); 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];
row_text[0] = ticonv_varname_to_utf8(options.calc_model, ve->name, ve->type);
row_text[2] = g_strdup_printf("%s", tifiles_vartype2string(options.calc_model, ve->type));
row_text[3] = g_strdup_printf("%u", (int) (ve->size));
strcpy(icon_name, tifiles_vartype2icon(options.calc_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(ctree_wnd));
g_object_unref(pix1);
g_object_unref(pix2);
g_object_unref(pix3);
g_object_unref(pix4);
g_object_unref(pix5);
g_object_unref(pix6);
tilp_remote_selection_destroy();
}
static void
g_node_test (void)
{
GNode *root;
GNode *node;
GNode *node_B;
GNode *node_D;
GNode *node_F;
GNode *node_G;
GNode *node_J;
guint i;
gchar *tstring;
failed = FALSE;
root = g_node_new (C2P ('A'));
TEST (NULL, g_node_depth (root) == 1 && g_node_max_height (root) == 1);
node_B = g_node_new (C2P ('B'));
g_node_append (root, node_B);
TEST (NULL, root->children == node_B);
g_node_append_data (node_B, C2P ('E'));
g_node_prepend_data (node_B, C2P ('C'));
node_D = g_node_new (C2P ('D'));
g_node_insert (node_B, 1, node_D);
node_F = g_node_new (C2P ('F'));
g_node_append (root, node_F);
TEST (NULL, root->children->next == node_F);
node_G = g_node_new (C2P ('G'));
g_node_append (node_F, node_G);
node_J = g_node_new (C2P ('J'));
g_node_prepend (node_G, node_J);
g_node_insert (node_G, 42, g_node_new (C2P ('K')));
g_node_insert_data (node_G, 0, C2P ('H'));
g_node_insert (node_G, 1, g_node_new (C2P ('I')));
TEST (NULL, g_node_depth (root) == 1);
TEST (NULL, g_node_max_height (root) == 4);
TEST (NULL, g_node_depth (node_G->children->next) == 4);
TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_LEAFS) == 7);
TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_NON_LEAFS) == 4);
TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_ALL) == 11);
TEST (NULL, g_node_max_height (node_F) == 3);
TEST (NULL, g_node_n_children (node_G) == 4);
TEST (NULL, g_node_find_child (root, G_TRAVERSE_ALL, C2P ('F')) == node_F);
TEST (NULL, g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, C2P ('I')) == NULL);
TEST (NULL, g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, C2P ('J')) == node_J);
for (i = 0; i < g_node_n_children (node_B); i++)
{
node = g_node_nth_child (node_B, i);
TEST (NULL, P2C (node->data) == ('C' + i));
}
for (i = 0; i < g_node_n_children (node_G); i++)
TEST (NULL, g_node_child_position (node_G, g_node_nth_child (node_G, i)) == i);
/* we have built: A
* / \
* B F
* / | \ \
* C D E G
* / /\ \
* H I J K
*
* for in-order traversal, 'G' is considered to be the "left"
* child of 'F', which will cause 'F' to be the last node visited.
*/
tstring = NULL;
g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABCDEFGHIJK") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_POST_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "CDEBHIJKGFA") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_IN_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "CBDEAHGIJKF") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABFCDEGHIJK") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_LEAFS, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "CDEHIJK") == 0);
g_free (tstring); tstring = NULL;
g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_NON_LEAFS, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABFG") == 0);
g_free (tstring); tstring = NULL;
g_node_reverse_children (node_B);
g_node_reverse_children (node_G);
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABFEDCGKJIH") == 0);
g_free (tstring); tstring = NULL;
g_node_append (node_D, g_node_new (C2P ('L')));
g_node_append (node_D, g_node_new (C2P ('M')));
g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
TEST (tstring, strcmp (tstring, "ABFEDCGLMKJIH") == 0);
g_free (tstring); tstring = NULL;
g_node_destroy (root);
/* allocation tests */
root = g_node_new (NULL);
node = root;
for (i = 0; i < 2048; i++)
{
g_node_append (node, g_node_new (NULL));
if ((i%5) == 4)
node = node->children->next;
}
TEST (NULL, g_node_max_height (root) > 100);
TEST (NULL, g_node_n_nodes (root, G_TRAVERSE_ALL) == 1 + 2048);
g_node_destroy (root);
if (failed)
exit(1);
}
/**
* ticalcs_dirlist_display:
* @tree: the tree to display.
*
* Display to stdout the tree content formatted in a tab.
*
* Return value: none.
**/
TIEXPORT3 void TICALL ticalcs_dirlist_display(GNode* tree)
{
GNode *vars = tree;
TreeInfo *info;
int i, j, k;
char *utf8;
if (tree == NULL)
{
ticalcs_critical("ticalcs_dirlist_display(NULL)");
return;
}
info = (TreeInfo *)(tree->data);
if (info == NULL)
return;
printf( "+------------------+----------+----+----+----------+----------+\n");
printf(_("| B. name | T. name |Attr|Type| Size | Folder |\n"));
printf( "+------------------+----------+----+----+----------+----------+\n");
for (i = 0; i < (int)g_node_n_children(vars); i++) // parse folders
{
GNode *parent = g_node_nth_child(vars, i);
VarEntry *fe = (VarEntry *) (parent->data);
if (fe != NULL)
{
utf8 = ticonv_varname_to_utf8(info->model, fe->name, -1);
printf("| ");
for (k = 0; k < 8; k++)
printf("%02X", (uint8_t) (fe->name)[k]);
printf(" | ");
printf("%8s", utf8);
printf(" | ");
printf("%2i", fe->attr);
printf(" | ");
printf("%02X", fe->type);
printf(" | ");
printf("%08X", fe->size);
printf(" | ");
printf("%8s", fe->folder);
printf(" |");
printf("\n");
g_free(utf8);
}
for (j = 0; j < (int)g_node_n_children(parent); j++) //parse variables
{
GNode *child = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (child->data);
utf8 = ticonv_varname_to_utf8(info->model, ve->name, ve->type);
printf("| ");
for (k = 0; k < 8; k++)
printf("%02X", (uint8_t) (ve->name)[k]);
printf(" | ");
printf("%8s", utf8);
printf(" | ");
printf("%2i", ve->attr);
printf(" | ");
printf("%02X", ve->type);
printf(" | ");
printf("%08X", ve->size);
printf(" | ");
printf("%8s", ve->folder);
printf(" |");
printf("\n");
g_free(utf8);
}
}
if (!i)
{
if(!strcmp(info->type, VAR_NODE_NAME))
printf(_("| No variables |\n"));
else if(!strcmp(info->type, APP_NODE_NAME))
printf(_("| No applications |\n"));
}
printf(_("+------------------+----------+----+----+----------+----------+"));
printf("\n");
}
/**
* ticalcs_calc_recv_tigroup:
* @handle: a previously allocated handle
* @filename: name of file
* @mode: which vars/apps to receive
*
* Receive a TiGroup file.
*
* Return value: 0 if ready else ERR_NOT_READY.
**/
TIEXPORT3 int TICALL ticalcs_calc_recv_tigroup(CalcHandle* handle, TigContent* content, TigMode mode)
{
int i, j;
int i_max, j_max;
GNode *vars, *apps;
int nvars = 0;
int napps = 0;
int b = 0;
if(handle == NULL) return ERR_INVALID_HANDLE;
if (content == NULL)
{
ticalcs_critical("ticalcs_calc_send_tigroup: content is NULL");
return -1;
}
update_->cnt3 = 0;
update_->pbar();
// Do a directory list and check for something to backup
TRYF(handle->calc->get_dirlist(handle, &vars, &apps));
if((mode & TIG_RAM) || (mode & TIG_ARCHIVE))
nvars = ticalcs_dirlist_ve_count(vars);
if(mode & TIG_FLASH)
napps = ticalcs_dirlist_ve_count(apps);
update_->cnt3 = 0;
update_->max3 = nvars + napps;
update_->pbar();
if(!nvars && !napps)
return ERR_NO_VARS;
// Check whether the last folder is empty
b = g_node_n_children(g_node_nth_child(vars, g_node_n_children(vars) - 1));
PAUSE(100); // needed by TI84+/USB
// Receive all vars
i_max = g_node_n_children(vars);
if((mode & TIG_RAM) || (mode & TIG_ARCHIVE))
for(i = 0; i < i_max; i++)
{
GNode *parent = g_node_nth_child(vars, i);
j_max = g_node_n_children(parent);
for(j = 0; j < j_max; j++)
{
GNode *node = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (node->data);
TigEntry *te;
char *filename;
char *varname;
char *fldname;
PAUSE(100);
TRYF(handle->calc->is_ready(handle));
PAUSE(100);
update_->cnt3++;
update_->pbar();
if(((mode & TIG_ARCHIVE) && (ve->attr == ATTRB_ARCHIVED)) ||
((mode & TIG_RAM) && ve->attr != ATTRB_ARCHIVED))
{
fldname = ticonv_varname_to_filename(handle->model, ve->folder, -1);
varname = ticonv_varname_to_filename(handle->model, ve->name, ve->type);
if(handle->calc->features & FTS_FOLDER)
filename = g_strconcat(fldname, ".", varname, ".",
tifiles_vartype2fext(handle->model, ve->type), NULL);
else
filename = g_strconcat(varname, ".",
tifiles_vartype2fext(handle->model, ve->type), NULL);
g_free(fldname);
g_free(varname);
te = tifiles_te_create(filename, TIFILE_SINGLE, handle->model);
g_free(filename);
TRYF(handle->calc->recv_var(handle, 0, te->content.regular, ve));
tifiles_content_add_te(content, te);
}
}
}
ticalcs_dirlist_destroy(&vars);
// Receive all apps
i_max = g_node_n_children(apps);
if(mode & TIG_FLASH)
for(i = 0; i < i_max; i++)
{
GNode *parent = g_node_nth_child(apps, i);
j_max = g_node_n_children(parent);
for(j = 0; j < j_max; j++)
{
GNode *node = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (node->data);
TigEntry *te;
char *filename;
char *basename;
TRYF(handle->calc->is_ready(handle));
update_->cnt3++;
update_->pbar();
basename = ticonv_varname_to_filename(handle->model, ve->name, ve->type);
filename = g_strconcat(basename, ".", tifiles_vartype2fext(handle->model, ve->type), NULL);
g_free(basename);
te = tifiles_te_create(filename, TIFILE_FLASH, handle->model);
g_free(filename);
TRYF(handle->calc->recv_app(handle, te->content.flash, ve));
tifiles_content_add_te(content, te);
}
}
ticalcs_dirlist_destroy(&apps);
return 0;
}
int tixx_recv_backup(CalcHandle* handle, BackupContent* content)
{
int i, j, k;
int i_max, j_max;
GNode *vars, *apps;
int nvars, ivars = 0;
int b = 0;
FileContent **group;
FileContent *single;
if(handle == NULL) return ERR_INVALID_HANDLE;
if (content == NULL)
{
ticalcs_critical("tixx_recv_backup: content is NULL");
return -1;
}
// Do a directory list and check for something to backup
TRYF(handle->calc->get_dirlist(handle, &vars, &apps));
nvars = ticalcs_dirlist_ve_count(vars);
if(!nvars)
return ERR_NO_VARS;
update_->cnt2 = update_->cnt3 = 0;
update_->max2 = update_->max3 = nvars;
update_->pbar();
// Check whether the last folder is empty
b = g_node_n_children(g_node_nth_child(vars, g_node_n_children(vars) - 1));
PAUSE(100); // needed by TI84+/USB
// Create a group file
k = 0;
group = tifiles_content_create_group(nvars);
// Receive all vars except for FLASH apps
i_max = g_node_n_children(vars);
for(i = 0; i < i_max; i++)
{
GNode *parent = g_node_nth_child(vars, i);
j_max = g_node_n_children(parent);
for(j = 0; j < j_max; j++)
{
GNode *node = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (node->data);
update_->cnt2 = update_->cnt3 = ++ivars;
update_->pbar();
// we need to group files !
TRYF(handle->calc->is_ready(handle));
group[k] = tifiles_content_create_regular(handle->model);
TRYF(handle->calc->recv_var(handle, 0, group[k++], ve));
}
}
ticalcs_dirlist_destroy(&vars);
ticalcs_dirlist_destroy(&apps);
tifiles_group_contents(group, &single);
tifiles_content_delete_group(group);
// Swap content and single because we have a pointer on an allocated content
{
FileContent* cnt = (FileContent *)content;
memcpy(content, single, sizeof(FileContent));
cnt->entries = single->entries;
strcpy(cnt->comment, tifiles_comment_set_group());
}
return 0;
}