TILP_EXPORT void action_rename_clicked(GtkButton * button, gpointer user_data)
{
GtkTreeModel *model = GTK_TREE_MODEL(list);
GtkTreeIter iter;
gboolean valid;
for (valid = gtk_tree_model_get_iter_first(model, &iter); valid;
valid = gtk_tree_model_iter_next(model, &iter))
{
FileEntry *f;
FileContent *c;
VarEntry *v;
VarEntry *w;
int n;
gchar *new_name = NULL;
gchar **row_text = g_malloc0(5 * sizeof(gchar *));
char *trans;
char full_name[260];
gtk_tree_model_get(model, &iter,
COLUMN_DATA_F, &f, COLUMN_DATA_V, &v, COLUMN_DATA_N, &n,
-1);
if (!f->selected)
continue;
// get new name
c = f->content1;
new_name = gif->msg_entry(_("Rename the file"), _("New name: "), tifiles_get_varname(v->name));
if (new_name == NULL)
continue;
// check that new varname does not exist
tifiles_build_fullname(options.calc_model, full_name, v->folder, new_name);
g_free(new_name);
w = ticalcs_dirlist_ve_exist(remote.var_tree, v);
// update action
v->attr = (w != NULL) ? w->attr : ATTRB_NONE;
v->action = (v->attr != ATTRB_NONE) ? ACT_SKIP : ACT_RENAME;
// update var entry
strncpy(v->folder, tifiles_get_fldname(full_name), 8); v->folder[8] = 0;
strncpy(v->name, tifiles_get_varname(full_name), 8); v->name[8] = 0;
trans = ticonv_varname_to_utf8(options.calc_model, (const char *)v->name, v->type);
// update entry
row_text[0] = g_strdup(trans); g_free(trans);
row_text[1] = g_strdup(tifiles_attribute_to_string(v->attr));
row_text[3] = g_strdup(action2string(v->action));
gtk_list_store_set(list, &iter,
COLUMN_VAR, row_text[0],
COLUMN_ATTR, row_text[1],
COLUMN_ACTION, row_text[3], -1);
g_strfreev(row_text); //bug
}
}
GLADE_CB void
on_add_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
char **array, **ptr;
CalcModel model;
FileContent *content;
int ret;
unsigned int i;
array = create_fsels(inst_paths.home_dir, "", "*.*");
if(array == NULL)
return;
for(ptr = array; *ptr; ptr++)
{
char *fn = *ptr;
if(tifiles_file_is_tigroup(fn))
{
msgbox_one(MSGBOX_ERROR, _("Importing of TiGroup files is not allowed."));
return;
}
model = tifiles_file_get_model(fn);
if(!tifiles_calc_are_compat(GFMFile.model, model))
{
msgbox_one(MSGBOX_ERROR, _("File is not compatible with current target."));
return;
}
content = tifiles_content_create_regular(model);
ret = tifiles_file_read_regular(fn, content);
for(i = 0; i < content->num_entries; i++)
{
VarEntry *ve = content->entries[i];
if(ticalcs_dirlist_ve_exist(GFMFile.trees.vars, ve))
{
msgbox_one(MSGBOX_ERROR, _("The entry already exists. Skipped!"));
continue;
}
ticalcs_dirlist_ve_add(GFMFile.trees.vars, ve);
}
ret = tifiles_content_delete_regular(content);
}
enable_save(TRUE);
enable_tree(TRUE);
ctree_refresh();
labels_refresh();
}
static void renderer_edited(GtkCellRendererText * cell,
const gchar * path_string,
const gchar * new_text, gpointer user_data)
{
GtkTreeModel *model = GTK_TREE_MODEL(tree);
GtkTreePath *path = gtk_tree_path_new_from_string(path_string);
GtkTreeIter iter;
const char *old_text;
VarEntry *ve;
gchar *str;
VarEntry *arg;
if (!gtk_tree_model_get_iter(model, &iter, path))
return;
gtk_tree_model_get(model, &iter, COLUMN_NAME, &old_text, -1);
gtk_tree_model_get(model, &iter, COLUMN_DATA, &ve, -1);
// tokenize and check for existence
str = ticonv_varname_tokenize(GFMFile.model, new_text, ve->type);
arg = tifiles_ve_dup(ve);
if(strlen(str) > 8)
str[8] = '\0';
strcpy(arg->name, str);
ticonv_varname_free(str);
if(ticalcs_dirlist_ve_exist(GFMFile.trees.vars, arg))
{
msgbox_one(MSGBOX_INFO, _("The name already exists. Please choose another one..."));
tifiles_ve_delete(arg);
return;
}
// update entry
strcpy(ve->name, arg->name);
tifiles_ve_delete(arg);
gtk_tree_store_set(tree, &iter, COLUMN_NAME, new_text, -1);
gtk_tree_path_free(path);
enable_save(TRUE);
}
/**
* ticalcs_calc_send_tigroup:
* @handle: a previously allocated handle
* @filename: name of file
* @mode: which vars/apps to send
*
* Send a TiGroup file.
*
* Return value: 0 if ready else ERR_NOT_READY.
**/
TIEXPORT3 int TICALL ticalcs_calc_send_tigroup(CalcHandle* handle, TigContent* content, TigMode mode)
{
TigEntry **ptr;
GNode *vars, *apps;
int nvars = 0;
int napps = 0;
if(handle == NULL) return ERR_INVALID_HANDLE;
if (content == NULL)
{
ticalcs_critical("ticalcs_calc_send_tigroup: content is NULL");
return -1;
}
TRYF(handle->calc->get_dirlist(handle, &vars, &apps));
if((mode & TIG_RAM) || (mode & TIG_ARCHIVE))
nvars = content->n_vars;
if(mode & TIG_FLASH)
napps = content->n_apps;
update_->cnt3 = 0;
update_->max3 = nvars + napps;
update_->pbar();
if((handle->model == CALC_TI89 || handle->model == CALC_TI92P ||
handle->model == CALC_TI89T || handle->model == CALC_V200) && (mode & TIG_BACKUP))
{
// erase memory
TRYF(ti89_send_VAR(handle, 0, TI89_BKUP, "main"));
TRYF(ti89_recv_ACK(handle, NULL));
TRYF(ti89_recv_CTS(handle));
TRYF(ti89_send_ACK(handle));
TRYF(ti89_send_EOT(handle));
TRYF(ti89_recv_ACK(handle, NULL));
}
// Send vars
if((mode & TIG_RAM) || (mode & TIG_ARCHIVE))
{
for(ptr = content->var_entries; *ptr; ptr++)
{
TigEntry *te = *ptr;
update_->cnt3++;
update_->pbar();
if((te->content.regular->entries[0]->attr == ATTRB_ARCHIVED) && !(mode & TIG_ARCHIVE))
continue;
if((te->content.regular->entries[0]->attr != ATTRB_ARCHIVED) && !(mode & TIG_RAM))
continue;
TRYF(handle->calc->send_var(handle, MODE_BACKUP, te->content.regular));
}
}
TRYF(handle->calc->is_ready(handle));
// Send apps
if(mode & TIG_FLASH)
{
for(ptr = content->app_entries; *ptr; ptr++)
{
TigEntry *te = *ptr;
VarEntry ve;
update_->cnt3++;
update_->pbar();
// can't overwrite apps so check before sending app
memset(&ve, 0, sizeof(VarEntry));
strcpy(ve.name, te->content.flash->name);
if(!ticalcs_dirlist_ve_exist(apps, &ve))
TRYF(handle->calc->send_app(handle, te->content.flash));
}
}
ticalcs_dirlist_destroy(&vars);
ticalcs_dirlist_destroy(&apps);
return 0;
}
gint display_action_dbox(gchar *target)
{
GtkBuilder *builder;
GError* error = NULL;
GtkWidget *dbox;
GtkWidget *data;
GtkTreeIter iter;
GList *sel;
int button = 0;
gint result;
gboolean empty = TRUE;
// update folder listing (if supported)
if (!(ticalcs_calc_features(calc_handle) & FTS_SILENT) )
return BUTTON1;
else
{
if(remote.var_tree == NULL)
{
if (tilp_dirlist_remote())
return BUTTON1;
ctree_refresh();
labels_refresh();
}
}
// box creation
builder = gtk_builder_new();
if (!gtk_builder_add_from_file (builder, tilp_paths_build_builder("action.ui"), &error))
{
g_warning (_("Couldn't load builder file: %s\n"), error->message);
g_error_free (error);
return 0; // THIS RETURNS !
}
gtk_builder_connect_signals(builder, NULL);
dbox = GTK_WIDGET (gtk_builder_get_object (builder, "action_dbox"));
gtk_dialog_set_alternative_button_order(GTK_DIALOG(dbox), GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,-1);
clist = data = GTK_WIDGET (gtk_builder_get_object (builder, "treeview1"));
// clist creation
create_clist(data);
// fill model
for (sel = local.selection1; sel != NULL; sel = sel->next)
{
FileEntry *f = (FileEntry *)sel->data;
FileContent *c = (FileContent *)f->content1;
if(f->content1 == NULL) // file can't be loaded
continue;
// we have now 1 VarEntry per FileContent
{
VarEntry *v = c->entries[0];
VarEntry *w;
gchar **row_text = g_malloc0(5 * sizeof(gchar *));
char *trans;
char full_name[260];
// modify attr or folder if target is specified
if(strcmp(target, ""))
{
if(!strcmp(target, "<FLASH>"))
{
v->attr = ATTRB_ARCHIVED;
}
else
{
strcpy(v->folder, target);
}
}
// search for matching var
tifiles_build_fullname(options.calc_model, full_name, v->folder, v->name);
trans = ticonv_varname_to_utf8(options.calc_model, (const char *)full_name, v->type);
w = ticalcs_dirlist_ve_exist(remote.var_tree, v);
if (w == NULL)
continue;
if(w->attr == ATTRB_LOCKED || w->attr == ATTRB_ARCHIVED)
v->action = ACT_SKIP;
else
v->action = ACT_SKIP; //don't overwrite as default behaviour
// file contains an already existing var: add it to the window
row_text[0] = trans;
row_text[1] = g_strdup(tifiles_attribute_to_string(v->attr));
row_text[2] = g_strdup(f->name);
row_text[3] = g_strdup(action2string(v->action));
tilp_vars_translate(row_text[0]);
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter,
COLUMN_VAR, row_text[0],
COLUMN_ATTR, row_text[1],
COLUMN_FILE, row_text[2],
COLUMN_ACTION, row_text[3],
COLUMN_DATA_F, (gpointer)f,
COLUMN_DATA_V, (gpointer)v,
-1);
g_strfreev(row_text);
empty = FALSE;
}
}
if (empty == TRUE)
{
button = BUTTON1; // skip box as ok
goto out_clean;
}
// select all vars
{
GtkTreeView *view = GTK_TREE_VIEW(clist);
GtkTreeSelection *sel2;
sel2 = gtk_tree_view_get_selection(view);
gtk_tree_selection_select_all(sel2);
}
// box running
gtk_dialog_set_default_response(GTK_DIALOG(dbox), GTK_RESPONSE_CANCEL);
result = gtk_dialog_run(GTK_DIALOG(dbox));
switch (result)
{
case GTK_RESPONSE_OK:
button = BUTTON1;
break;
case GTK_RESPONSE_CANCEL:
button = BUTTON2;
default:
button = BUTTON2;
break;
}
out_clean:
gtk_widget_destroy(dbox);
return button;
}
