/**
* 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;
}
GLADE_CB void
on_save_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
gchar *fn = NULL, *ext = NULL;
gchar *filename = NULL;
if(GFMFile.filename != NULL)
filename = g_strdup(GFMFile.filename);
if(GFMFile.type & TIFILE_TIGROUP)
{
ext = g_strdup("*.tig");
}
else if(GFMFile.type & TIFILE_GROUP)
{
if(ticalcs_dirlist_ve_count(GFMFile.trees.vars) > 1)
{
// Group file
ext = g_strconcat("*.", tifiles_vartype2fext(GFMFile.model, 0x00), NULL);
ext[4] = 'g';
}
else if(ticalcs_dirlist_ve_count(GFMFile.trees.vars) == 1)
{
// Single file
GNode *parent, *child;
VarEntry *ve;
parent = g_node_nth_child(GFMFile.trees.vars, 0);
child = g_node_nth_child(parent, 0);
ve = (VarEntry *) (child->data);
filename = g_strconcat(ticonv_varname_to_filename(GFMFile.model, ve->name, ve->type), ".",
tifiles_vartype2fext(GFMFile.model, ve->type), NULL);
ext = g_strconcat("*.", tifiles_vartype2fext(GFMFile.model, ve->type), NULL);
}
else
{
g_free(filename);
return;
}
}
fn = (char *)create_fsel(inst_paths.home_dir, filename, ext, TRUE);
if(fn == NULL)
return;
g_free(filename);
g_free(ext);
file_save(fn);
g_free(GFMFile.filename);
GFMFile.filename = g_strdup(fn);
enable_save(FALSE);
}
GladeModelData *
glade_model_data_tree_get_data (GNode * data_tree, gint row, gint colnum)
{
GNode *node;
g_return_val_if_fail (data_tree != NULL, NULL);
if ((node = g_node_nth_child (data_tree, row)) != NULL)
if ((node = g_node_nth_child (node, colnum)) != NULL)
return (GladeModelData *) node->data;
return NULL;
}
/**
* 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 void
glade_eprop_model_data_delete_selected (GladeEditorProperty * eprop)
{
GtkTreeIter iter;
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GNode *data_tree = NULL, *row;
gint rownum = -1;
/* NOTE: This will trigger row-deleted below... */
if (!gtk_tree_selection_get_selected (eprop_data->selection, NULL, &iter))
return;
gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,
COLUMN_ROW, &rownum, -1);
g_assert (rownum >= 0);
/* if theres a sected row, theres data... */
glade_property_get (property, &data_tree);
g_assert (data_tree);
data_tree = glade_model_data_tree_copy (data_tree);
row = g_node_nth_child (data_tree, rownum);
g_node_unlink (row);
glade_model_data_tree_free (row);
if (eprop_data->pending_data_tree)
glade_model_data_tree_free (eprop_data->pending_data_tree);
eprop_data->pending_data_tree = data_tree;
g_idle_add ((GSourceFunc) update_data_tree_idle, eprop);
}
/**
* 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;
}
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);
}
}
}
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;
}
/**
* 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));
}
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);
}
}
/**
* g_node_insert:
* @parent: the #GNode to place @node under
* @position: the position to place @node at, with respect to its siblings
* If position is -1, @node is inserted as the last child of @parent
* @node: the #GNode to insert
*
* Inserts a #GNode beneath the parent at the given position.
*
* Returns: the inserted #GNode
*/
GNode*
g_node_insert (GNode *parent,
gint position,
GNode *node)
{
g_return_val_if_fail (parent != NULL, node);
g_return_val_if_fail (node != NULL, node);
g_return_val_if_fail (G_NODE_IS_ROOT (node), node);
if (position > 0)
return g_node_insert_before (parent,
g_node_nth_child (parent, position),
node);
else if (position == 0)
return g_node_prepend (parent, node);
else /* if (position < 0) */
return g_node_append (parent, node);
}
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);
}
}
static gboolean
data_changed_idle (GladeEditorProperty * eprop)
{
GladeEPropModelData *eprop_data = GLADE_EPROP_MODEL_DATA (eprop);
GladeProperty *property = glade_editor_property_get_property (eprop);
GNode *data_tree = NULL, *new_tree, *row;
GtkTreeIter iter;
gint rownum;
glade_property_get (property, &data_tree);
g_assert (data_tree);
new_tree = g_node_new (NULL);
if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (eprop_data->store), &iter))
{
do
{
gtk_tree_model_get (GTK_TREE_MODEL (eprop_data->store), &iter,
COLUMN_ROW, &rownum, -1);
if ((row = g_node_nth_child (data_tree, rownum)) != NULL)
{
/* Make a new tree by copying row by row... */
row = glade_model_data_tree_copy (row);
g_node_append (new_tree, row);
}
}
while (gtk_tree_model_iter_next
(GTK_TREE_MODEL (eprop_data->store), &iter));
}
/* Were already in an idle, no need to idle from here... */
if (eprop_data->pending_data_tree)
glade_model_data_tree_free (eprop_data->pending_data_tree);
eprop_data->pending_data_tree = new_tree;
update_data_tree_idle (eprop);
return FALSE;
}
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);
}
void
glade_model_data_column_rename (GNode * node,
const gchar * column_name,
const gchar * new_name)
{
gint idx;
GNode *row, *iter;
GladeModelData *data;
g_return_if_fail (node != NULL);
if ((idx = glade_model_data_column_index (node, column_name)) < 0)
return;
for (row = node->children; row; row = row->next)
{
iter = g_node_nth_child (row, idx);
data = iter->data;
g_free (data->name);
data->name = g_strdup (new_name);
}
}
/**
* 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++;
}
}
int tixx_recv_all_vars_backup(CalcHandle* handle, FileContent* content)
{
int i, j, k;
int i_max;
GNode *vars, *apps;
int nvars, ivars = 0;
int b = 0;
FileContent **group;
FileContent *single;
int ret;
VALIDATE_HANDLE(handle);
if (content == NULL)
{
ticalcs_critical("tixx_recv_backup: content is NULL");
return -1;
}
VALIDATE_CALCFNCTS(handle->calc);
// Do a directory list and check for something to backup
ret = handle->calc->get_dirlist(handle, &vars, &apps);
if (ret)
{
return ret;
}
nvars = ticalcs_dirlist_ve_count(vars);
if (!nvars)
{
return ERR_NO_VARS;
}
handle->updat->cnt2 = handle->updat->cnt3 = 0;
handle->updat->max2 = handle->updat->max3 = nvars;
ticalcs_update_pbar(handle);
// 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);
int 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);
handle->updat->cnt2 = handle->updat->cnt3 = ++ivars;
ticalcs_update_pbar(handle);
// we need to group files !
ret = handle->calc->is_ready(handle);
if (ret)
{
goto end;
}
group[k] = tifiles_content_create_regular(handle->model);
ret = handle->calc->recv_var(handle, 0, group[k++], ve);
if (ret)
{
goto end;
}
}
}
end:
ticalcs_dirlist_destroy(&vars);
ticalcs_dirlist_destroy(&apps);
if (!ret)
{
FileContent * cnt;
ret = tifiles_group_contents(group, &cnt);
if (!ret)
{
cnt->model = content->model;
// Steal contents of cnt, then clean up.
memcpy(content, cnt, sizeof(*content));
cnt->num_entries = 0;
cnt->entries = NULL;
tifiles_content_delete_regular(cnt);
ticalcs_strlcpy(content->comment, tifiles_comment_set_group(), sizeof(content->comment));
}
}
tifiles_content_delete_group(group);
return ret;
}
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 MimeInfo *pgpmime_decrypt(MimeInfo *mimeinfo)
{
MimeInfo *encinfo, *decinfo, *parseinfo;
gpgme_data_t cipher = NULL, plain = NULL;
static gint id = 0;
FILE *dstfp;
gchar *fname;
gpgme_verify_result_t sigstat = NULL;
PrivacyDataPGP *data = NULL;
gpgme_ctx_t ctx;
gchar *chars;
size_t len;
gpgme_error_t err;
if ((err = gpgme_new(&ctx)) != GPG_ERR_NO_ERROR) {
debug_print(("Couldn't initialize GPG context, %s\n"), gpgme_strerror(err));
privacy_set_error(_("Couldn't initialize GPG context, %s"), gpgme_strerror(err));
return NULL;
}
cm_return_val_if_fail(pgpmime_is_encrypted(mimeinfo), NULL);
encinfo = (MimeInfo *) g_node_nth_child(mimeinfo->node, 1)->data;
cipher = sgpgme_data_from_mimeinfo(encinfo);
plain = sgpgme_decrypt_verify(cipher, &sigstat, ctx);
gpgme_data_release(cipher);
if (plain == NULL) {
debug_print("plain is null!\n");
gpgme_release(ctx);
return NULL;
}
fname = g_strdup_printf("%s%cplaintext.%08x",
get_mime_tmp_dir(), G_DIR_SEPARATOR, ++id);
if ((dstfp = claws_fopen(fname, "wb")) == NULL) {
FILE_OP_ERROR(fname, "claws_fopen");
privacy_set_error(_("Couldn't open decrypted file %s"), fname);
g_free(fname);
gpgme_data_release(plain);
gpgme_release(ctx);
debug_print("can't open!\n");
return NULL;
}
if (fprintf(dstfp, "MIME-Version: 1.0\n") < 0) {
FILE_OP_ERROR(fname, "fprintf");
claws_fclose(dstfp);
privacy_set_error(_("Couldn't write to decrypted file %s"), fname);
g_free(fname);
gpgme_data_release(plain);
gpgme_release(ctx);
debug_print("can't open!\n");
return NULL;
}
chars = sgpgme_data_release_and_get_mem(plain, &len);
if (len > 0) {
if (claws_fwrite(chars, 1, len, dstfp) < len) {
FILE_OP_ERROR(fname, "claws_fwrite");
g_free(chars);
claws_fclose(dstfp);
privacy_set_error(_("Couldn't write to decrypted file %s"), fname);
g_free(fname);
gpgme_data_release(plain);
gpgme_release(ctx);
debug_print("can't open!\n");
return NULL;
}
}
g_free(chars);
if (claws_safe_fclose(dstfp) == EOF) {
FILE_OP_ERROR(fname, "claws_fclose");
privacy_set_error(_("Couldn't close decrypted file %s"), fname);
g_free(fname);
gpgme_data_release(plain);
gpgme_release(ctx);
debug_print("can't open!\n");
return NULL;
}
parseinfo = procmime_scan_file(fname);
g_free(fname);
if (parseinfo == NULL) {
gpgme_release(ctx);
privacy_set_error(_("Couldn't parse decrypted file."));
return NULL;
}
decinfo = g_node_first_child(parseinfo->node) != NULL ?
g_node_first_child(parseinfo->node)->data : NULL;
if (decinfo == NULL) {
privacy_set_error(_("Couldn't parse decrypted file parts."));
gpgme_release(ctx);
return NULL;
}
g_node_unlink(decinfo->node);
procmime_mimeinfo_free_all(&parseinfo);
decinfo->tmp = TRUE;
if (sigstat != NULL && sigstat->signatures != NULL) {
if (decinfo->privacy != NULL) {
data = (PrivacyDataPGP *) decinfo->privacy;
} else {
data = pgpmime_new_privacydata();
decinfo->privacy = (PrivacyData *) data;
}
if (data != NULL) {
data->done_sigtest = TRUE;
data->is_signed = TRUE;
data->sigstatus = sigstat;
if (data->ctx)
gpgme_release(data->ctx);
data->ctx = ctx;
}
} else
gpgme_release(ctx);
return decinfo;
}
/**
* 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");
}
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;
}
/**
* 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;
}
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_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;
GNode *vars, *apps;
int nvars = 0;
int napps = 0;
int b = 0;
int ret;
VALIDATE_HANDLE(handle);
if (content == NULL)
{
ticalcs_critical("ticalcs_calc_send_tigroup: content is NULL");
return -1;
}
VALIDATE_CALCFNCTS(handle->calc);
handle->updat->cnt3 = 0;
ticalcs_update_pbar(handle);
// Do a directory list and check for something to backup
ret = handle->calc->get_dirlist(handle, &vars, &apps);
if (ret)
{
return ret;
}
if ((mode & TIG_RAM) || (mode & TIG_ARCHIVE))
{
nvars = ticalcs_dirlist_ve_count(vars);
}
if (mode & TIG_FLASH)
{
napps = ticalcs_dirlist_ve_count(apps);
}
handle->updat->cnt3 = 0;
handle->updat->max3 = nvars + napps;
ticalcs_update_pbar(handle);
if (!nvars && !napps)
{
ret = ERR_NO_VARS; // THIS RETURNS !
goto end;
}
// 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
if ((mode & TIG_RAM) || (mode & TIG_ARCHIVE))
{
int i_max = g_node_n_children(vars);
for (i = 0; i < i_max; i++)
{
GNode *parent = g_node_nth_child(vars, i);
int 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;
PAUSE(100);
ret = handle->calc->is_ready(handle);
if (ret)
{
goto end;
}
PAUSE(100);
handle->updat->cnt3++;
ticalcs_update_pbar(handle);
if (((mode & TIG_ARCHIVE) && (ve->attr == ATTRB_ARCHIVED)) ||
((mode & TIG_RAM) && ve->attr != ATTRB_ARCHIVED))
{
char *filename;
char *varname = ticonv_varname_to_filename(handle->model, ve->name, ve->type);
char *fldname = ticonv_varname_to_filename(handle->model, ve->folder, -1);
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(varname);
g_free(fldname);
te = tifiles_te_create(filename, TIFILE_SINGLE, handle->model);
g_free(filename);
if (te != NULL)
{
ret = handle->calc->recv_var(handle, 0, te->content.regular, ve);
if (ret)
{
tifiles_te_delete(te);
goto end;
}
tifiles_content_add_te(content, te);
}
else
{
ret = ERR_MALLOC;
goto end;
}
}
}
}
}
// Receive all apps
if (mode & TIG_FLASH)
{
int i_max = g_node_n_children(apps);
for(i = 0; i < i_max; i++)
{
GNode *parent = g_node_nth_child(apps, i);
int 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;
ret = handle->calc->is_ready(handle);
if (ret)
{
goto end;
}
handle->updat->cnt3++;
ticalcs_update_pbar(handle);
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);
if (te != NULL)
{
ret = handle->calc->recv_app(handle, te->content.flash, ve);
if (ret)
{
tifiles_te_delete(te);
goto end;
}
tifiles_content_add_te(content, te);
}
else
{
ret = ERR_MALLOC;
goto end;
}
}
}
}
end:
ticalcs_dirlist_destroy(&apps);
ticalcs_dirlist_destroy(&vars);
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--;
}
}
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();
}
// 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;
}
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps)
{
TreeInfo *ti;
int err;
GNode *root, *folder = NULL;
char varname[VARNAME_MAX];
uint32_t varsize;
uint8_t vartype;
int i;
(*apps) = g_node_new(NULL);
ti = (TreeInfo *)g_malloc(sizeof(TreeInfo));
ti->model = handle->model;
ti->type = APP_NODE_NAME;
(*apps)->data = ti;
(*vars) = g_node_new(NULL);
ti = (TreeInfo *)g_malloc(sizeof(TreeInfo));
ti->model = handle->model;
ti->type = VAR_NODE_NAME;
(*vars)->data = ti;
root = g_node_new(NULL);
g_node_append(*apps, root);
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
TRYF(nsp_cmd_s_dir_attributes(handle, "/"));
TRYF(nsp_cmd_r_dir_attributes(handle, NULL, NULL, NULL));
TRYF(nsp_session_close(handle));
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
TRYF(nsp_cmd_s_dir_enum_init(handle, "/"));
TRYF(nsp_cmd_r_dir_enum_init(handle));
for(;;)
{
VarEntry *fe;
GNode *node;
TRYF(nsp_cmd_s_dir_enum_next(handle));
err = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype);
if (err == ERR_EOT)
break;
else if (err != 0)
return err;
fe = tifiles_ve_create();
strcpy(fe->folder, varname);
strcpy(fe->name, varname);
fe->size = varsize;
fe->type = vartype;
fe->attr = ATTRB_NONE;
node = g_node_new(fe);
folder = g_node_append(*vars, node);
ticalcs_info(_("Name: %s | Type: %8s | Attr: %i | Size: %08X"),
fe->name,
tifiles_vartype2string(handle->model, fe->type),
fe->attr,
fe->size);
}
TRYF(nsp_cmd_s_dir_enum_done(handle));
TRYF(nsp_cmd_r_dir_enum_done(handle));
for(i = 0; i < (int)g_node_n_children(*vars); i++)
{
char *folder_name;
char *u1, *u2;
folder = g_node_nth_child(*vars, i);
folder_name = ((VarEntry *) (folder->data))->name;
vartype = ((VarEntry *) (folder->data))->type;
// Skip entries whose type is 0 (TNS), for example themes.csv on OS 3.0+.
if (vartype == 0)
{
ticalcs_info(_("Not enumerating documents in %s because it's not a folder"), folder_name);
continue;
}
ticalcs_info(_("Directory listing in <%s>..."), folder_name);
TRYF(nsp_cmd_s_dir_enum_init(handle, folder_name));
TRYF(nsp_cmd_r_dir_enum_init(handle));
for(;;)
{
VarEntry *ve = tifiles_ve_create();
GNode *node;
char *ext;
TRYF(nsp_cmd_s_dir_enum_next(handle));
err = nsp_cmd_r_dir_enum_next(handle, varname, &varsize, &vartype);
if (err == ERR_EOT)
break;
else if (err != 0)
return err;
ext = tifiles_fext_get(varname);
strcpy(ve->folder, folder_name);
ve->size = varsize;
ve->type = tifiles_fext2vartype(handle->model, ext);
ve->attr = ATTRB_NONE;
// 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 (ve->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.
}
strcpy(ve->name, varname);
node = g_node_new(ve);
g_node_append(folder, node);
ticalcs_info(_("Name: %8s | Type: %8s | Attr: %i | Size: %08X"),
ve->name,
tifiles_vartype2string(handle->model, ve->type),
ve->attr,
ve->size);
u1 = ticonv_varname_to_utf8(handle->model, ((VarEntry *) (folder->data))->name, -1);
u2 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s/%s"), u1, u2);
g_free(u1); g_free(u2);
update_label();
}
TRYF(nsp_cmd_s_dir_enum_done(handle));
TRYF(nsp_cmd_r_dir_enum_done(handle));
}
TRYF(nsp_session_close(handle));
return 0;
}