static int rename_var (CalcHandle* handle, VarRequest* oldname, VarRequest* newname)
{
char *utf81, *utf82;
char *path1, *path2;
int ret;
ret = nsp_session_open(handle, NSP_SID_FILE_MGMT);
if (ret)
{
return ret;
}
path1 = build_path(handle->model, oldname);
path2 = build_path(handle->model, newname);
utf81 = ticonv_varname_to_utf8(handle->model, path1, oldname->type);
utf82 = ticonv_varname_to_utf8(handle->model, path2, newname->type);
ticalcs_slprintf(update_->text, sizeof(update_->text), _("Renaming %s to %s..."), utf81, utf82);
ticonv_utf8_free(utf82);
ticonv_utf8_free(utf81);
update_label();
ret = nsp_cmd_s_rename_file(handle, path1, path2);
g_free(path2);
g_free(path1);
if (!ret)
{
ret = nsp_cmd_r_rename_file(handle);
}
DO_CLOSE_SESSION(handle);
return ret;
}
static int del_var (CalcHandle* handle, VarRequest* vr)
{
char *utf8;
char *path;
int err;
const char * dot_if_any = ".";
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
// Don't add a dot if this file type is unknown.
if (vr->type >= NSP_MAXTYPES)
dot_if_any = "";
path = g_strconcat("/", vr->folder, "/", vr->name, dot_if_any,
tifiles_vartype2fext(handle->model, vr->type), NULL);
utf8 = ticonv_varname_to_utf8(handle->model, path, vr->type);
g_snprintf(update_->text, sizeof(update_->text), _("Deleting %s..."), utf8);
g_free(utf8);
update_label();
err = nsp_cmd_s_del_file(handle, path);
g_free(path);
if (err)
{
return err;
}
TRYF(nsp_cmd_r_del_file(handle));
TRYF(nsp_session_close(handle));
return 0;
}
static int new_folder (CalcHandle* handle, VarRequest* vr)
{
char *utf8;
char *path;
int err;
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
path = g_strconcat("/", vr->folder, NULL);
utf8 = ticonv_varname_to_utf8(handle->model, path, -1);
g_snprintf(update_->text, sizeof(update_->text), _("Creating %s..."), utf8);
g_free(utf8);
update_label();
err = nsp_cmd_s_new_folder(handle, path);
g_free(path);
if (err)
{
return err;
}
TRYF(nsp_cmd_r_new_folder(handle));
TRYF(nsp_session_close(handle));
return 0;
}
static int recv_var (CalcHandle* handle, CalcMode mode, FileContent* content, VarRequest* vr)
{
char *path;
uint8_t *data = NULL;
VarEntry *ve;
char *utf8;
int err;
const char * dot_if_any = ".";
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
// Don't add a dot if this file type is unknown.
if (vr->type >= NSP_MAXTYPES)
dot_if_any = "";
path = g_strconcat("/", vr->folder, "/", vr->name, dot_if_any,
tifiles_vartype2fext(handle->model, vr->type), NULL);
utf8 = ticonv_varname_to_utf8(handle->model, path, vr->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
err = nsp_cmd_s_get_file(handle, path);
g_free(path);
if (err)
{
return err;
}
TRYF(nsp_cmd_r_get_file(handle, &(vr->size)));
TRYF(nsp_cmd_s_file_ok(handle));
if (vr->size)
TRYF(nsp_cmd_r_file_contents(handle, &(vr->size), &data));
TRYF(nsp_cmd_s_status(handle, ERR_OK));
content->model = handle->model;
strcpy(content->comment, tifiles_comment_set_single());
content->num_entries = 1;
content->entries = tifiles_ve_create_array(1);
ve = content->entries[0] = tifiles_ve_create();
memcpy(ve, vr, sizeof(VarEntry));
ve->data = tifiles_ve_alloc_data(ve->size);
if (data && ve->data)
{
memcpy(ve->data, data, ve->size);
}
g_free(data);
// XXX don't check the result of this call, to enable reception of variables from Nspires running OS >= 1.7.
// Those versions send a martian packet:
// * a src port never seen before in the conversation;
// * an improper dest port;
// * a 1-byte payload containing 02 (i.e. an invalid address for the next packet).
// * .ack = 0x00 (instead of 0x0A).
nsp_session_close(handle);
return 0;
}
static void display_node(TreeInfo * info, VarEntry * ve, unsigned char type)
{
char * utf8 = ticonv_varname_to_utf8(info->model, ve->name, type);
int k;
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");
ticonv_utf8_free(utf8);
}
static int new_folder (CalcHandle* handle, VarRequest* vr)
{
char *utf8;
char *path;
int ret;
ret = nsp_session_open(handle, NSP_SID_FILE_MGMT);
if (ret)
{
return ret;
}
path = g_strconcat("/", vr->folder, NULL);
utf8 = ticonv_varname_to_utf8(handle->model, path, -1);
ticalcs_slprintf(update_->text, sizeof(update_->text), _("Creating %s..."), utf8);
ticonv_utf8_free(utf8);
update_label();
ret = nsp_cmd_s_new_folder(handle, path);
g_free(path);
if (!ret)
{
ret = nsp_cmd_r_new_folder(handle);
}
DO_CLOSE_SESSION(handle);
return ret;
}
static int del_var (CalcHandle* handle, VarRequest* vr)
{
unsigned int i;
char *utf8;
utf8 = ticonv_varname_to_utf8(handle->model, vr->name, vr->type);
g_snprintf(update_->text, sizeof(update_->text), _("Deleting %s..."), utf8);
g_free(utf8);
update_label();
send_key(handle, 0x0040); // Quit
send_key(handle, 0x0009); // Clear
send_key(handle, 0x0009); // Clear
send_key(handle, 0x003e); // Catalog
send_key(handle, 0x009d); // D
send_key(handle, 0x0004); // Down
send_key(handle, 0x0004); // Down
send_key(handle, 0x0004); // Down
send_key(handle, 0x0005); // Enter
for(i = 0; i < strlen(vr->name); i++)
{
char c = toupper(vr->name[i]);
if(isdigit(c))
send_key(handle, (uint16_t)(0x008e + c - '0'));
else
send_key(handle, (uint16_t)(0x009a + c - 'A'));
}
send_key(handle, 0x0005); // Enter
return 0;
}
static int new_folder (CalcHandle* handle, VarRequest* vr)
{
uint8_t data[16] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x40, 0x00, 0x21, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23 };
char varname[18];
char *utf8;
tifiles_build_fullname(handle->model, varname, vr->folder, "a1234567");
utf8 = ticonv_varname_to_utf8(handle->model, vr->folder, -1);
g_snprintf(update_->text, sizeof(update_->text), _("Creating %s..."), utf8);
g_free(utf8);
update_label();
// send empty expression
TRYF(ti92_send_RTS(0x10, 0x00, varname));
TRYF(ti92_recv_ACK(NULL));
TRYF(ti92_recv_CTS());
TRYF(ti92_send_ACK());
TRYF(ti92_send_XDP(0x10, data));
TRYF(ti92_recv_ACK(NULL));
TRYF(ti92_send_EOT());
TRYF(ti92_recv_ACK(NULL));
// delete 'a1234567' variable
strcpy(vr->name, "a1234567");
TRYF(del_var(handle, vr));
return 0;
}
static int del_var (CalcHandle* handle, VarRequest* vr)
{
char *utf8;
char *path;
int ret;
ret = nsp_session_open(handle, NSP_SID_FILE_MGMT);
if (ret)
{
return ret;
}
path = build_path(handle->model, vr);
utf8 = ticonv_varname_to_utf8(handle->model, path, vr->type);
ticalcs_slprintf(update_->text, sizeof(update_->text), _("Deleting %s..."), utf8);
ticonv_utf8_free(utf8);
update_label();
ret = nsp_cmd_s_del_file(handle, path);
g_free(path);
if (!ret)
{
ret = nsp_cmd_r_del_file(handle);
}
DO_CLOSE_SESSION(handle);
return ret;
}
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
}
}
static int rename_var (CalcHandle* handle, VarRequest* oldname, VarRequest* newname)
{
char *utf81, *utf82;
char *path1, *path2;
int err;
const char * dot_if_any = ".";
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
// Don't add a dot if this file type is unknown.
if (oldname->type >= NSP_MAXTYPES)
dot_if_any = "";
path1 = g_strconcat("/", oldname->folder, "/", oldname->name, dot_if_any,
tifiles_vartype2fext(handle->model, oldname->type), NULL);
dot_if_any = ".";
// Don't add a dot if this file type is unknown.
if (oldname->type >= NSP_MAXTYPES)
dot_if_any = "";
path2 = g_strconcat("/", newname->folder, "/", newname->name, dot_if_any,
tifiles_vartype2fext(handle->model, newname->type), NULL);
utf81 = ticonv_varname_to_utf8(handle->model, path1, oldname->type);
utf82 = ticonv_varname_to_utf8(handle->model, path2, newname->type);
g_snprintf(update_->text, sizeof(update_->text), _("Renaming %s to %s..."), utf81, utf82);
g_free(utf82);
g_free(utf81);
update_label();
err = nsp_cmd_s_rename_file(handle, path1, path2);
g_free(path2);
g_free(path1);
if (err)
{
return err;
}
TRYF(nsp_cmd_r_rename_file(handle));
TRYF(nsp_session_close(handle));
return 0;
}
static int send_var (CalcHandle* handle, CalcMode mode, FileContent* content)
{
int i;
uint8_t rej_code;
uint16_t status;
char *utf8;
update_->cnt2 = 0;
update_->max2 = content->num_entries;
for (i = 0; i < content->num_entries; i++)
{
VarEntry *entry = content->entries[i];
if(entry->action == ACT_SKIP)
continue;
TRYF(ti82_send_RTS(handle, (uint16_t)entry->size, entry->type, entry->name));
TRYF(ti82_recv_ACK(handle, &status));
TRYF(ti82_recv_SKP(handle, &rej_code));
TRYF(ti82_send_ACK(handle));
switch (rej_code)
{
case REJ_EXIT:
return ERR_ABORT;
case REJ_SKIP:
continue;
case REJ_MEMORY:
return ERR_OUT_OF_MEMORY;
default: // RTS
break;
}
utf8 = ticonv_varname_to_utf8(handle->model, entry->name, entry->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
TRYF(ti82_send_XDP(handle, entry->size, entry->data));
TRYF(ti82_recv_ACK(handle, &status));
TRYF(ti82_send_EOT(handle));
ticalcs_info("");
update_->cnt2 = i+1;
update_->max2 = content->num_entries;
update_->pbar();
}
return 0;
}
static int send_var (CalcHandle* handle, CalcMode mode, FileContent* content)
{
char *utf8;
uint8_t status;
const char * dot_if_any = ".";
update_->cnt2 = 0;
update_->max2 = 1;
update_->pbar();
{
VarEntry *ve = content->entries[0];
gchar *path;
int err;
if(ve->action == ACT_SKIP)
return 0;
if(!strlen(ve->folder))
return ERR_ABORT;
TRYF(nsp_session_open(handle, SID_FILE_MGMT));
// Don't add a dot if this file type is unknown.
if (ve->type >= NSP_MAXTYPES)
dot_if_any = "";
path = g_strconcat("/", ve->folder, "/", ve->name, dot_if_any,
tifiles_vartype2fext(handle->model, ve->type), NULL);
utf8 = ticonv_varname_to_utf8(handle->model, path, ve->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
err = nsp_cmd_s_put_file(handle, path, ve->size);
g_free(path);
if (err)
{
return err;
}
TRYF(nsp_cmd_r_put_file(handle));
TRYF(nsp_cmd_s_file_contents(handle, ve->size, ve->data));
TRYF(nsp_cmd_r_status(handle, &status));
TRYF(nsp_session_close(handle));
}
return 0;
}
static int send_var (CalcHandle* handle, CalcMode mode, FileContent* content)
{
int i;
uint16_t status;
char *utf8;
update_->cnt2 = 0;
update_->max2 = content->num_entries;
for (i = 0; i < content->num_entries; i++)
{
VarEntry *entry = content->entries[i];
uint8_t buffer[65536 + 4] = { 0 };
char varname[18];
if(entry->action == ACT_SKIP)
continue;
if (mode & MODE_LOCAL_PATH)
strcpy(varname, entry->name);
else
tifiles_build_fullname(handle->model, varname, entry->folder, entry->name);
utf8 = ticonv_varname_to_utf8(handle->model, varname, entry->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
TRYF(ti92_send_VAR(entry->size, entry->type, varname));
TRYF(ti92_recv_ACK(NULL));
TRYF(ti92_recv_CTS());
TRYF(ti92_send_ACK());
memcpy(buffer + 4, entry->data, entry->size);
TRYF(ti92_send_XDP(entry->size + 4, buffer));
TRYF(ti92_recv_ACK(&status));
TRYF(ti92_send_EOT());
TRYF(ti92_recv_ACK(NULL));
ticalcs_info("");
update_->cnt2 = i+1;
update_->max2 = content->num_entries;
update_->pbar();
}
return 0;
}
static int recv_var (CalcHandle* handle, CalcMode mode, FileContent* content, VarRequest* vr)
{
uint16_t aids[] = { AID_ARCHIVED, AID_VAR_VERSION, AID_VAR_SIZE };
const int naids = sizeof(aids) / sizeof(uint16_t);
CalcAttr **attrs;
const int nattrs = 1;
char fldname[40], varname[40];
uint8_t *data;
VarEntry *ve;
char *utf8;
utf8 = ticonv_varname_to_utf8(handle->model, vr->name, vr->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
attrs = ca_new_array(nattrs);
attrs[0] = ca_new(AID_VAR_TYPE2, 4);
attrs[0]->data[0] = 0xF0; attrs[0]->data[1] = 0x07;
attrs[0]->data[2] = 0x00; attrs[0]->data[3] = vr->type;
TRYF(cmd_s_var_request(handle,"",vr->name,naids,aids,nattrs,CA(attrs)));
ca_del_array(nattrs, attrs);
attrs = ca_new_array(naids);
TRYF(cmd_r_var_header(handle, fldname, varname, attrs));
TRYF(cmd_r_var_content(handle, NULL, &data));
content->model = handle->model;
strcpy(content->comment, tifiles_comment_set_single());
content->num_entries = 1;
content->entries = tifiles_ve_create_array(1);
ve = content->entries[0] = tifiles_ve_create();
memcpy(ve, vr, sizeof(VarEntry));
ve->size = GINT32_FROM_BE(*((uint32_t *)(attrs[2]->data)));
ve->data = tifiles_ve_alloc_data(ve->size);
memcpy(ve->data, data, ve->size);
g_free(data);
ca_del_array(naids, attrs);
return 0;
}
static int recv_var (CalcHandle* handle, CalcMode mode, FileContent* content, VarRequest* vr)
{
uint16_t status;
VarEntry *ve;
uint32_t unused;
char varname[18];
char *utf8;
content->model = CALC_TI92;
strcpy(content->comment, tifiles_comment_set_single());
content->num_entries = 1;
content->entries = tifiles_ve_create_array(1);
ve = content->entries[0] = tifiles_ve_create();
memcpy(ve, vr, sizeof(VarEntry));
tifiles_build_fullname(handle->model, varname, vr->folder, vr->name);
utf8 = ticonv_varname_to_utf8(handle->model, varname, vr->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
TRYF(ti92_send_REQ(0, vr->type, varname));
TRYF(ti92_recv_ACK(&status));
if (status != 0)
return ERR_MISSING_VAR;
TRYF(ti92_recv_VAR(&ve->size, &ve->type, ve->name));
TRYF(ti92_send_ACK());
TRYF(ti92_send_CTS());
TRYF(ti92_recv_ACK(NULL));
ve->data = tifiles_ve_alloc_data(ve->size + 4);
TRYF(ti92_recv_XDP(&unused, ve->data));
memmove(ve->data, ve->data + 4, ve->size);
TRYF(ti92_send_ACK());
TRYF(ti92_recv_EOT());
TRYF(ti92_send_ACK());
return 0;
}
static int del_var (CalcHandle* handle, VarRequest* vr)
{
int ret = 0;
static const uint16_t keys[] = {
0x40, 0x09, 0x09, /* Quit, Clear, Clear, */
0x3e, 0x9d, 0x04, /* Catalog, D, Down */
0x04, 0x04, 0x05 /* Down, Down, Enter */
};
unsigned int i;
char *utf8;
utf8 = ticonv_varname_to_utf8(handle->model, vr->name, vr->type);
ticalcs_slprintf(update_->text, sizeof(update_->text), _("Deleting %s..."), utf8);
ticonv_utf8_free(utf8);
update_label();
// Input keys by remote control
for (i = 0; !ret && i < sizeof(keys) / sizeof(keys[0]); i++)
{
ret = send_key(handle, (uint32_t)(keys[i]));
}
for (i = 0; !ret && i < strlen(vr->name); i++)
{
char c = toupper(vr->name[i]);
if (isdigit(c))
{
ret = send_key(handle, (uint32_t)(0x008e + c - '0'));
}
else
{
ret = send_key(handle, (uint32_t)(0x009a + c - 'A'));
}
}
if (!ret)
{
ret = send_key(handle, 0x0005); // Enter
}
return ret;
}
static int del_var (CalcHandle* handle, VarRequest* vr)
{
int ret;
char *utf8;
utf8 = ticonv_varname_to_utf8(handle->model, vr->name, vr->type);
ticalcs_slprintf(handle->updat->text, sizeof(handle->updat->text), _("Deleting %s..."), utf8);
ticonv_utf8_free(utf8);
ticalcs_update_label(handle);
ret = SEND_DEL(handle, (uint16_t)vr->size, vr->type, vr->name, vr->attr);
if (!ret)
{
ret = RECV_ACK(handle, NULL);
if (!ret)
{
ret = RECV_ACK(handle, NULL);
}
}
return ret;
}
static int send_var (CalcHandle* handle, CalcMode mode, FileContent* content)
{
int i;
char *utf8;
CalcAttr **attrs;
const int nattrs = 3;
for (i = 0; i < content->num_entries; i++)
{
VarEntry *ve = content->entries[i];
if(ve->action == ACT_SKIP)
continue;
utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
attrs = ca_new_array(nattrs);
attrs[0] = ca_new(AID_VAR_TYPE, 4);
attrs[0]->data[0] = 0xF0; attrs[0]->data[1] = 0x07;
attrs[0]->data[2] = 0x00; attrs[0]->data[3] = ve->type;
attrs[1] = ca_new(AID_ARCHIVED, 1);
attrs[1]->data[0] = ve->attr == ATTRB_ARCHIVED ? 1 : 0;
attrs[2] = ca_new(AID_VAR_VERSION, 4);
TRYF(cmd_s_rts(handle,"",ve->name,ve->size,nattrs,CA(attrs)));
TRYF(cmd_r_data_ack(handle));
TRYF(cmd_s_var_content(handle, ve->size, ve->data));
TRYF(cmd_r_data_ack(handle));
TRYF(cmd_s_eot(handle));
PAUSE(50); // needed
}
return 0;
}
static int recv_var (CalcHandle* handle, CalcMode mode, FileContent* content, VarRequest* vr)
{
uint16_t unused;
VarEntry *ve;
char *utf8;
uint16_t ve_size;
content->model = CALC_TI83;
strcpy(content->comment, tifiles_comment_set_single());
content->num_entries = 1;
content->entries = tifiles_ve_create_array(1);
ve = content->entries[0] = tifiles_ve_create();
memcpy(ve, vr, sizeof(VarEntry));
utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
// silent request
TRYF(ti82_send_REQ(handle, (uint16_t)vr->size, vr->type, vr->name));
TRYF(ti82_recv_ACK(handle, &unused));
TRYF(ti82_recv_VAR(handle, &ve_size, &ve->type, ve->name));
ve->size = ve_size;
TRYF(ti82_send_ACK(handle));
TRYF(ti82_send_CTS(handle));
TRYF(ti82_recv_ACK(handle, NULL));
ve->data = tifiles_ve_alloc_data(ve->size);
TRYF(ti82_recv_XDP(handle, &ve_size, ve->data));
ve->size = ve_size;
TRYF(ti82_send_ACK(handle));
return 0;
}
static int del_var (CalcHandle* handle, VarRequest* vr)
{
CalcAttr **attr;
const int size = 2;
char *utf8;
utf8 = ticonv_varname_to_utf8(handle->model, vr->name, vr->type);
g_snprintf(update_->text, sizeof(update_->text), _("Deleting %s..."), utf8);
g_free(utf8);
update_label();
attr = ca_new_array(size);
attr[0] = ca_new(0x0011, 4);
attr[0]->data[0] = 0xF0; attr[0]->data[1] = 0x0B;
attr[0]->data[2] = 0x00; attr[0]->data[3] = vr->type;
attr[1] = ca_new(0x0013, 1);
attr[1]->data[0] = vr->attr == ATTRB_ARCHIVED ? 1 : 0;
TRYF(cmd_s_var_delete(handle, "", vr->name, size, CA(attr)));
TRYF(cmd_r_data_ack(handle));
ca_del_array(size, attr);
return 0;
}
static int del_var (CalcHandle* handle, VarRequest* vr)
{
int i;
char varname[18];
char *utf8;
tifiles_build_fullname(handle->model, varname, vr->folder, vr->name);
utf8 = ticonv_varname_to_utf8(handle->model, varname, vr->type);
g_snprintf(update_->text, sizeof(update_->text), _("Deleting %s..."), utf8);
g_free(utf8);
update_label();
send_key(handle, KEY92P_ON);
send_key(handle, KEY92P_ESC);
send_key(handle, KEY92P_ESC);
send_key(handle, KEY92P_ESC);
send_key(handle, KEY92P_2ND + KEY92P_ESC);
send_key(handle, KEY92P_2ND + KEY92P_ESC);
send_key(handle, KEY92P_CTRL + KEY92P_Q);
send_key(handle, KEY92P_CLEAR);
send_key(handle, KEY92P_CLEAR);
send_key(handle, 'd');
send_key(handle, 'e');
send_key(handle, 'l');
send_key(handle, 'v');
send_key(handle, 'a');
send_key(handle, 'r');
send_key(handle, KEY92P_SPACE);
for(i = 0; i < (int)strlen(varname); i++)
send_key(handle, varname[i]);
send_key(handle, KEY92P_ENTER);
return 0;
}
static int recv_var_ns (CalcHandle* handle, CalcMode mode, FileContent* content, VarEntry** vr)
{
uint32_t unused;
int nvar, err;
char tipath[18];
char *tiname;
char *utf8;
content->model = handle->model;
// receive packets
for(nvar = 1;; nvar++)
{
VarEntry *ve;
content->entries = tifiles_ve_resize_array(content->entries, nvar+1);
ve = content->entries[nvar-1] = tifiles_ve_create();;
strcpy(ve->folder, "main");
err = ti92_recv_VAR(&ve->size, &ve->type, tipath);
TRYF(ti92_send_ACK());
if(err == ERR_EOT) // end of transmission
goto exit;
else
content->num_entries = nvar;
// from Christian (TI can send varname or fldname/varname)
if ((tiname = strchr(tipath, '\\')) != NULL)
{
*tiname = '\0';
strcpy(ve->folder, tipath);
strcpy(ve->name, tiname + 1);
}
else
{
strcpy(ve->folder, "main");
strcpy(ve->name, tipath);
}
utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
TRYF(ti92_send_CTS());
TRYF(ti92_recv_ACK(NULL));
ve->data = tifiles_ve_alloc_data(ve->size + 4);
TRYF(ti92_recv_XDP(&unused, ve->data));
memmove(ve->data, ve->data + 4, ve->size);
TRYF(ti92_send_ACK());
}
exit:
nvar--;
if(nvar > 1)
*vr = NULL;
else
*vr = tifiles_ve_dup(content->entries[0]);
return 0;
}
/*
The main function
*/
int main(int argc, char **argv)
{
int i, j;
unsigned int n = 0;
int is_utf8 = ticonv_environment_is_utf8();
charsets[0] = ti73_charset;
charsets[1] = ti82_charset;
charsets[2] = ti83_charset;
charsets[3] = ti83p_charset;
charsets[4] = ti85_charset;
charsets[5] = ti86_charset;
charsets[6] = ti9x_charset;
// test ticonv.c
printf("Library version : <%s>\n", ticonv_version_get());
printf("--\n");
printf("Choose your charset: ");
if (!scanf("%u", &n))
{
n = 0;
}
if (n >= 7)
{
n = 6;
}
printf(" 0 1 2 3 4 5 6 7 8 9 A B C D E F\n");
for(i = 0; i < 16; i++)
{
printf("%x ", i);
for(j = 0; j < 16; j++)
{
unsigned long wc = charsets[n][16*i+j];
gchar *str = NULL;
if (wc && wc != '\n')
{
gunichar2 buf[4] = { 0 };
buf[0] = (gunichar2)wc;
str = ticonv_utf16_to_utf8(buf);
if (!is_utf8 && str)
{
gchar *tmp = g_locale_from_utf8(str, -1, NULL, NULL, NULL);
ticonv_utf8_free(str);
str = tmp;
}
}
else
{
str = NULL;
}
if (str)
{
printf("%s ", str);
}
ticonv_utf8_free(str);
}
printf("\n");
}
{
char ti82_varname[9] = { 0 };
char ti92_varname[9] = { 0 };
char ti84p_varname[36] = { 0 };
char *utf8;
char *filename;
char *varname;
ti82_varname[0] = 0x5d; // L1
ti82_varname[1] = 0x01;
ti82_varname[2] = 0;
ti92_varname[0] = (char)132; // delta
ti92_varname[1] = (char)0xE9; // e acute.
ti92_varname[2] = 0;
ti84p_varname[0] = 'L'; // L1 in TI-UTF-8
ti84p_varname[1] = (char)0xE2;
ti84p_varname[2] = (char)0x82;
ti84p_varname[3] = (char)0x81;
// TI -> UTF-8
utf8 = ticonv_varname_to_utf8(CALC_TI82, ti82_varname, -1);
printf("UTF-8 varname: <%s> (%i)\n", ti82_varname, (int)strlen(ti82_varname));
ticonv_utf8_free(utf8);
utf8 = ticonv_varname_to_utf8(CALC_TI92, ti92_varname, -1);
printf("UTF-8 varname: <%s> (%i)\n", ti92_varname, (int)strlen(ti92_varname));
ticonv_utf8_free(utf8);
utf8 = ticonv_varname_to_utf8(CALC_TI84P_USB, ti84p_varname, -1);
printf("UTF-8 varname: <%s> (%i)\n", ti84p_varname, (int)strlen(ti84p_varname));
ticonv_utf8_free(utf8);
// TI -> filename
printf("raw varname: <%s> (%i)\n", ti92_varname, (int)strlen(ti92_varname));
filename = ticonv_varname_to_filename(CALC_TI92, ti92_varname, -1);
printf("filename: <%s>\n", filename);
ticonv_gfe_free(filename);
printf("raw varname: <%s> (%i)\n", ti82_varname, (int)strlen(ti82_varname));
filename = ticonv_varname_to_filename(CALC_TI82, ti82_varname, -1);
printf("filename: <%s>\n", filename);
ticonv_gfe_free(filename);
printf("raw varname: <%s> (%i)\n", ti84p_varname, (int)strlen(ti84p_varname));
filename = ticonv_varname_to_filename(CALC_TI84P_USB, ti84p_varname, -1);
printf("filename: <%s>\n", filename);
ticonv_gfe_free(filename);
// varname -> varname
printf("raw varname: <%s> (%i)\n", ti84p_varname, (int)strlen(ti84p_varname));
varname = ticonv_varname_to_tifile(CALC_TI84P_USB, ti84p_varname, -1);
printf("varname: <%s>\n", varname);
ticonv_gfe_free(varname);
}
#ifdef __WIN32__
while(!_kbhit());
#endif
return 0;
}
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps)
{
TreeInfo *ti;
VarEntry info;
uint32_t unused;
uint8_t buffer[65536];
int err;
char folder_name[9] = "";
GNode *folder = NULL;
char *utf8;
// get list of folders & FLASH apps
(*vars) = g_node_new(NULL);
ti = (TreeInfo *)g_malloc(sizeof(TreeInfo));
ti->model = handle->model;
ti->type = VAR_NODE_NAME;
(*vars)->data = ti;
(*apps) = g_node_new(NULL);
ti = (TreeInfo *)g_malloc(sizeof(TreeInfo));
ti->model = handle->model;
ti->type = APP_NODE_NAME;
(*apps)->data = ti;
TRYF(ti92_send_REQ(0, TI92_RDIR, ""));
TRYF(ti92_recv_ACK(NULL));
TRYF(ti92_recv_VAR(&info.size, &info.type, info.name));
for (;;)
{
VarEntry *ve = tifiles_ve_create();
GNode *node;
TRYF(ti92_send_ACK());
TRYF(ti92_send_CTS());
TRYF(ti92_recv_ACK(NULL));
TRYF(ti92_recv_XDP(&unused, buffer));
memcpy(ve->name, buffer + 4, 8); // skip 4 extra 00s
ve->name[8] = '\0';
ve->type = buffer[12];
ve->attr = buffer[13];
ve->size = buffer[14] | (buffer[15] << 8) | (buffer[16] << 16) | (buffer[17] << 24);
strcpy(ve->folder, "");
if (ve->type == TI92_DIR)
{
strcpy(folder_name, ve->name);
node = g_node_new(ve);
folder = g_node_append(*vars, node);
}
else
{
strcpy(ve->folder, folder_name);
if(!strcmp(ve->folder, "main") &&
(!strcmp(ve->name, "regcoef") || !strcmp(ve->name, "regeq")))
{
tifiles_ve_delete(ve);
}
else
{
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);
TRYF(ti92_send_ACK());
err = ti92_recv_CNT();
if (err == ERR_EOT)
break;
TRYF(err);
utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s/%s"),
((VarEntry *) (folder->data))->name, utf8);
g_free(utf8);
update_->label();
}
TRYF(ti92_send_ACK());
return 0;
}
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps)
{
TreeInfo *ti;
GNode *folder;
uint16_t unused;
uint32_t memory;
char *utf8;
// get list of folders & FLASH apps
(*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;
TRYF(ti82_send_REQ(handle, 0x0000, TI83_DIR, ""));
TRYF(ti82_recv_ACK(handle, &unused));
TRYF(ti82_recv_XDP(handle, &unused, (uint8_t *)&memory));
fixup(memory);
TRYF(ti82_send_ACK(handle));
ti->mem_free = memory;
folder = g_node_new(NULL);
g_node_append(*vars, folder);
// Add permanent variables (Window, RclWindow, TblSet aka WINDW, ZSTO, TABLE)
{
GNode *node;
VarEntry *ve;
ve = tifiles_ve_create();
ve->type = TI83_WINDW;
node = g_node_new(ve);
g_node_append(folder, node);
ve = tifiles_ve_create();
ve->type = TI83_ZSTO;
node = g_node_new(ve);
g_node_append(folder, node);
ve = tifiles_ve_create();
ve->type = TI83_TABLE;
node = g_node_new(ve);
g_node_append(folder, node);
}
for (;;)
{
VarEntry *ve = tifiles_ve_create();
GNode *node;
int err;
uint16_t ve_size;
err = ti82_recv_VAR(handle, &ve_size, &ve->type, ve->name);
ve->size = ve_size;
TRYF(ti82_send_ACK(handle));
if (err == ERR_EOT)
break;
else if (err != 0)
return err;
node = g_node_new(ve);
g_node_append(folder, node);
utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s"), utf8);
g_free(utf8);
update_label();
}
return 0;
}
static int get_dirlist (CalcHandle* handle, GNode** vars, GNode** apps)
{
TreeInfo *ti;
GNode *folder;
uint16_t unused;
uint8_t hl, ll, lh;
uint8_t mem[8];
char *utf8;
// get list of folders & FLASH apps
(*vars) = g_node_new(NULL);
ti = (TreeInfo *)g_malloc(sizeof(TreeInfo));
ti->model = handle->model;
ti->type = VAR_NODE_NAME;
(*vars)->data = ti;
(*apps) = g_node_new(NULL);
ti = (TreeInfo *)g_malloc(sizeof(TreeInfo));
ti->model = handle->model;
ti->type = APP_NODE_NAME;
(*apps)->data = ti;
TRYF(ti85_send_REQ(0x0000, TI86_DIR, ""));
TRYF(ti85_recv_ACK(&unused));
TRYF(ti85_recv_XDP(&unused, mem));
TRYF(ti85_send_ACK());
hl = mem[0];
ll = mem[1];
lh = mem[2];
ti->mem_free = (hl << 16) | (lh << 8) | ll;
folder = g_node_new(NULL);
g_node_append(*vars, folder);
// Add permanent variables (Func, Pol, Param, DifEq, ZRCL as WIND, WIND, WIND, WIND, WIND)
{
GNode *node;
VarEntry *ve;
ve = tifiles_ve_create();
ve->type = TI86_FUNC;
node = g_node_new(ve);
g_node_append(folder, node);
ve = tifiles_ve_create();
ve->type = TI86_POL;
node = g_node_new(ve);
g_node_append(folder, node);
ve = tifiles_ve_create();
ve->type = TI86_PARAM;
node = g_node_new(ve);
g_node_append(folder, node);
ve = tifiles_ve_create();
ve->type = TI86_DIFEQ;
node = g_node_new(ve);
g_node_append(folder, node);
ve = tifiles_ve_create();
ve->type = TI86_ZRCL;
node = g_node_new(ve);
g_node_append(folder, node);
}
for (;;)
{
VarEntry *ve = tifiles_ve_create();
GNode *node;
int err;
uint16_t ve_size;
err = ti85_recv_VAR(&ve_size, &ve->type, ve->name);
ve->size = ve_size;
TRYF(ti85_send_ACK());
if (err == ERR_EOT)
break;
else if (err != 0)
return err;
node = g_node_new(ve);
g_node_append(folder, node);
utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), _("Parsing %s"), utf8);
g_free(utf8);
update_label();
}
return 0;
}
/**
* 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");
}
static int recv_var_ns (CalcHandle* handle, CalcMode mode, FileContent* content, VarEntry** vr)
{
int nvar = 0;
int err = 0;
char *utf8;
uint16_t ve_size;
g_snprintf(update_->text, sizeof(update_->text), _("Waiting for var(s)..."));
update_label();
content->model = CALC_TI82;
for (nvar = 0;; nvar++)
{
VarEntry *ve;
content->entries = tifiles_ve_resize_array(content->entries, nvar+1);
ve = content->entries[nvar] = tifiles_ve_create();
do
{
update_refresh();
if (update_->cancel)
return ERR_ABORT;
err = ti82_recv_VAR(&ve_size, &(ve->type), ve->name);
ve->size = ve_size;
}
while (err == ERROR_READ_TIMEOUT);
TRYF(ti82_send_ACK());
if (err == ERR_EOT)
goto exit;
TRYF(err);
TRYF(ti82_send_CTS());
TRYF(ti82_recv_ACK(NULL));
utf8 = ticonv_varname_to_utf8(handle->model, ve->name, ve->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
ve->data = tifiles_ve_alloc_data(ve->size);
TRYF(ti82_recv_XDP(&ve_size, ve->data));
ve->size = ve_size;
TRYF(ti82_send_ACK());
}
exit:
content->num_entries = nvar;
if(nvar == 1)
{
strcpy(content->comment, tifiles_comment_set_single());
*vr = tifiles_ve_dup(content->entries[0]);
}
else
{
strcpy(content->comment, tifiles_comment_set_group());
*vr = NULL;
}
return 0;
}
static int send_var_ns (CalcHandle* handle, CalcMode mode, FileContent* content)
{
int i;
int err;
uint8_t rej_code;
uint16_t status;
char *utf8;
update_->cnt2 = 0;
update_->max2 = content->num_entries;
for (i = 0; i < content->num_entries; i++)
{
VarEntry *entry = content->entries[i];
TRYF(ti82_send_VAR((uint16_t)entry->size, entry->type, entry->name));
TRYF(ti82_recv_ACK(&status));
g_snprintf(update_->text, sizeof(update_->text), _("Waiting for user's action..."));
update_label();
do
{ // wait user's action
update_refresh();
if (update_->cancel)
return ERR_ABORT;
err = ti82_recv_SKP(&rej_code);
}
while (err == ERROR_READ_TIMEOUT);
TRYF(ti82_send_ACK());
switch (rej_code)
{
case REJ_EXIT:
return ERR_ABORT;
case REJ_SKIP:
continue;
case REJ_MEMORY:
return ERR_OUT_OF_MEMORY;
default: // RTS
break;
}
utf8 = ticonv_varname_to_utf8(handle->model, entry->name, entry->type);
g_snprintf(update_->text, sizeof(update_->text), "%s", utf8);
g_free(utf8);
update_label();
TRYF(ti82_send_XDP(entry->size, entry->data));
TRYF(ti82_recv_ACK(&status));
update_->cnt2 = i+1;
update_->max2 = content->num_entries;
update_->pbar();
}
if ((mode & MODE_SEND_ONE_VAR) || (mode & MODE_SEND_LAST_VAR))
{
TRYF(ti82_send_EOT());
TRYF(ti82_recv_ACK(NULL));
}
return 0;
}
