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