// Send TIGroup
TILP_EXPORT void on_tilp_button8_clicked(GtkButton* button, gpointer user_data)
{
const char *filename;
int ret;
int mode = TIG_ALL;
ret = backup_box(_("Restore"), _("Data to restore:"), &mode);
if(ret != BUTTON1)
return;
#if 1
filename = create_fsel(local.cwdir, NULL, "*.tig", FALSE);
if(filename)
tilp_calc_send_tigroup(filename, mode);
#else
if(local.selection2 == NULL)
return;
if(g_list_length(local.selection) > 1)
return;
{
FileEntry *f = (FileEntry *) local.selection->data;
if(!tifiles_file_is_tigroup(f->name))
return;
tilp_calc_send_tigroup(f->name, mode);
}
#endif
return;
}
void fs_send_file(const gchar *filename)
{
int err;
// set pbar title
if(tifiles_file_is_flash(filename))
{
create_pbar_(FNCT_SEND_APP, _("Sending app(s)"));
}
else if(tifiles_file_is_group(filename))
{
create_pbar_(FNCT_SEND_VAR, _("Sending var(s)"));
}
else if(tifiles_file_is_backup(filename))
{
create_pbar_(FNCT_SEND_BACKUP, _("Restoring"));
}
else if(tifiles_file_is_single(filename))
{
create_pbar_(FNCT_SEND_VAR, _("Sending var(s)"));
}
else if(tifiles_file_is_tigroup(filename))
{
create_pbar_type5(_("Restoring"));
}
// note that core is currently not bkpt-interruptible when
// transferring file
GTK_REFRESH();
err = ti68k_linkport_send_file(filename);
handle_error();
destroy_pbar();
}
int gfm_tifiles_group(const char **filenames, int type)
{
char **ptr;
gchar *input;
gchar *target = NULL;
gchar *dirname = g_path_get_dirname(filenames[0]);
// gchar *basename = g_path_get_basename(filenames[0]);
int err = 0;
// Check for selection consistency
for(ptr = (char **)filenames; *ptr; ptr++)
{
if(tifiles_file_is_group(*ptr) || tifiles_file_is_tigroup(*ptr))
{
msgbox_one(MSGBOX_ERROR, _("Group files are not allowed in selection."));
return -1;
}
if(tifiles_file_is_flash(*ptr) && type != TIFILE_TIGROUP)
{
msgbox_one(MSGBOX_ERROR, _("FLASH files are not allowed in group files."));
return -1;
}
}
// Ask for group name
input = msgbox_input(_("Group files"), "group", _("Group name: "));
if(input == NULL)
return -1;
// And group
if(type == TIFILE_GROUP)
{
target = g_strconcat(dirname, G_DIR_SEPARATOR_S, input, ".",
tifiles_fext_of_group(tifiles_file_get_model(filenames[0])), NULL);
g_free(input);
err = tifiles_group_files((char **)filenames, target);
}
else if(type == TIFILE_TIGROUP)
{
target = g_strconcat(dirname, G_DIR_SEPARATOR_S, input, ".tig", NULL);
g_free(input);
err = tifiles_tigroup_files((char **)filenames, target);
}
if(err)
{
gchar *str;
tifiles_error_get(err, &str);
msgbox_one(MSGBOX_ERROR, str);
g_free(str);
}
g_free(target);
return 0;
}
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();
}
/**
* tifiles_file_is_single:
* @filename: a filename as string.
*
* Check whether file is a single TI file (like program, function, ...).
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_file_is_single(const char *filename)
{
if (!tifiles_file_is_ti(filename))
return 0;
if (!tifiles_file_is_group(filename) &&
!tifiles_file_is_backup(filename) &&
!tifiles_file_is_flash(filename) &&
!tifiles_file_is_tigroup(filename))
return !0;
return 0;
}
/**
* tifiles_file_get_class:
* @filename: a filename as string.
*
* Returns the file class (single, group, backup, flash).
*
* Return value: a value in #FileClass.
**/
TIEXPORT2 FileClass TICALL tifiles_file_get_class(const char *filename)
{
if (tifiles_file_is_single(filename))
return TIFILE_SINGLE;
else if (tifiles_file_is_group(filename))
return TIFILE_GROUP;
else if (tifiles_file_is_backup(filename))
return TIFILE_BACKUP;
else if (tifiles_file_is_flash(filename))
return TIFILE_FLASH;
else if (tifiles_file_is_tigroup(filename))
return TIFILE_TIGROUP;
else
return 0;
}
GLADE_CB void
on_open_clicked (GtkToolButton *toolbutton,
gpointer user_data)
{
gchar *fn;
if(user_data == NULL)
{
if(GFMFile.contents.group || GFMFile.contents.tigroup)
{
int result = msgbox_two(MSGBOX_YESNO, _("Do you want to save previous file?"));
if(result == MSGBOX_YES)
on_save_clicked(toolbutton,user_data);
}
fn = (char *)create_fsel(inst_paths.home_dir, "", "*.73?;*.82?;*.83?;*.8X?;*.85?;*.86?;*.89?;*.92?;*.9x?;*.V2?;*.tig", FALSE);
if(fn == NULL)
return;
}
else
{
// command line
fn = (char *)user_data;
}
if(tifiles_file_is_tigroup(fn))
GFMFile.type = TIFILE_TIGROUP;
else if(tifiles_file_is_regular(fn))
GFMFile.type = TIFILE_GROUP;
else
return;
file_load(fn);
g_free(GFMFile.filename);
GFMFile.filename = g_strdup(fn);
enable_save(FALSE);
enable_tree(TRUE);
ctree_refresh();
labels_refresh();
g_free(inst_paths.home_dir);
inst_paths.home_dir = g_path_get_dirname(GFMFile.filename);
}
void tilp_local_selection_add(const char* filename)
{
FileEntry* fe = g_malloc0(sizeof(FileEntry));
fe->name = g_strdup(filename);
if(tifiles_file_is_regular(fe->name))
local.selection0 = g_list_prepend(local.selection0, fe);
else if(tifiles_file_is_flash(fe->name))
local.selection2 = g_list_prepend(local.selection2, fe);
else if(tifiles_file_is_backup(fe->name))
local.selection4 = g_list_prepend(local.selection4, fe);
else if(tifiles_file_is_tigroup(fe->name))
local.selection5 = g_list_prepend(local.selection5, fe);
}
GLADE_CB void
on_ungroup_clicked (GtkButton *button,
gpointer user_data)
{
char *fn;
fn = (char *)create_fsel(inst_paths.home_dir, "", "*.73g;*.82g;*.83g;*.8Xg;*.85g;*.86g;*.89g;*.92g;*.9Xg;*.V2g;*.tig", FALSE);
if(fn == NULL)
return;
if(tifiles_file_is_tigroup(fn))
gfm_tifiles_ungroup(fn, TIFILE_TIGROUP);
else if(tifiles_file_is_regular(fn))
gfm_tifiles_ungroup(fn, TIFILE_GROUP);
else
return;
}
/**
* tifiles_file_display:
* @filename: a TI file.
*
* Determine file class and display internal content.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int TICALL tifiles_file_display(const char *filename)
{
if (tifiles_file_is_tigroup(filename))
return tifiles_file_display_tigroup(filename);
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(tifiles_file_get_model(filename)))
return ti8x_file_display(filename);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(tifiles_file_get_model(filename)))
return ti9x_file_display(filename);
else
#endif
return ERR_BAD_CALC;
return 0;
}
int fs_send_files(gchar **filenames)
{
gchar **ptr;
int i, l;
// check extension and send
for(ptr = filenames, l = 0; *ptr; ptr++, l++);
for(ptr = filenames, i = 0; *ptr; ptr++, i++)
{
if(!tifiles_file_is_ti(*ptr) || (!tifiles_calc_is_ti9x(tifiles_file_get_model(*ptr)) &&
!tifiles_file_is_tigroup(*ptr)))
{
msg_box1(_("Error"), _("This file is not a valid TI file."));
g_strfreev(filenames);
return -1;
}
fs_send_file(*ptr);
}
return 0;
}
// Restore
TILP_EXPORT void on_tilp_button4_clicked(GtkButton* button, gpointer user_data)
{
const char *filename;
char *ext;
int mode = TIG_ALL | TIG_BACKUP;
ext = g_strconcat("*.", tifiles_fext_of_backup(options.calc_model), ";*.tig", NULL);
filename = create_fsel(local.cwdir, NULL, ext, FALSE);
g_free(ext);
if(filename)
{
if(tifiles_file_is_tigroup(filename))
{
int ret = backup_box(_("Restore"), _("Data to restore:"), &mode);
if(ret != BUTTON1)
return;
tilp_calc_send_tigroup(filename, mode | TIG_BACKUP);
}
else if(tifiles_file_is_backup(filename))
tilp_calc_send_backup(filename);
}
}
/* Preload TI variables belonging with the selection */
void tilp_local_contents_load(void)
{
GList *ptr;
int err;
// TIGroups
if (local.selection5 != NULL)
{
for(ptr = local.selection5; ptr; ptr = ptr->next)
{
FileEntry *fe5 = ptr->data;
if(tifiles_file_is_tigroup(fe5->name))
{
TigContent *content = NULL;
FileContent **p, **contents1 = NULL;
FlashContent **q, **contents2 = NULL;
content = tifiles_content_create_tigroup(options.calc_model, 0);
err = tifiles_file_read_tigroup(fe5->name, content);
if(err)
{
tilp_err(err);
continue;
}
err = tifiles_untigroup_content(content, &contents1, &contents2);
if(err)
{
tilp_err(err);
tifiles_content_delete_tigroup(content);
continue;
}
tifiles_content_delete_tigroup(content);
for(p = contents1; *p; p++)
{
FileEntry *fe1 = g_memdup(ptr->data, sizeof(FileEntry));
fe1->name = g_memdup(fe1->name, strlen(fe1->name)+1);
fe1->content1 = *p;
//g_free(fe1->name);
//fe1->name = tifiles_build_filename(options.calc_model, (*p)->entries[0]);
local.selection1 = g_list_append(local.selection1, fe1);
}
for(q = contents2; *q; q++)
{
FileEntry *fe3 = g_memdup(ptr->data, sizeof(FileEntry));
fe3->name = g_memdup(fe3->name, strlen(fe3->name)+1);
fe3->content2 = *q;
/*
{
VarEntry ve;
g_free(fe3->name);
strcpy(ve.name, (*q)->name);
ve.type = (*q)->data_type;
fe3->name = tifiles_build_filename(options.calc_model, &ve);
}*/
local.selection3 = g_list_append(local.selection3, fe3);
}
}
}
}
// Variables
if (local.selection0 != NULL)
{
for(ptr = local.selection0; ptr; ptr = ptr->next)
{
FileEntry *fe0 = ptr->data;
if(!g_ascii_strcasecmp(tifiles_fext_get(fe0->name), "8xidl"))
continue; // doesn't send this pseudo-variable
if(tifiles_file_is_single(fe0->name))
{
FileEntry *fe1 = g_memdup(ptr->data, sizeof(FileEntry));
fe1->content1 = tifiles_content_create_regular(options.calc_model);
err = tifiles_file_read_regular(fe1->name, fe1->content1);
if(err)
{
// The content is already deleted by the subroutines of tifiles_file_read_regular.
//tifiles_content_delete_regular(fe1->content1);
g_free(fe1);
continue;
}
local.selection1 = g_list_append(local.selection1, fe1);
}
else if(tifiles_file_is_group(fe0->name))
{
// explode group files so that we have 1 VarEntry per item (skip/retry/cancel)
FileContent **p, **dst = NULL;
FileContent *src = NULL;
src = tifiles_content_create_regular(options.calc_model);
err = tifiles_file_read_regular(fe0->name, src);
if(err)
{
// The content is already deleted by the subroutines of tifiles_file_read_regular.
//tifiles_content_delete_regular(src);
continue;
}
err = tifiles_ungroup_content(src, &dst);
if(err)
{
tifiles_content_delete_regular(src);
continue;
}
for(p = dst; *p; p++)
{
FileEntry *fe = g_memdup(ptr->data, sizeof(FileEntry));
fe->content1 = *p;
local.selection1 = g_list_append(local.selection1, fe);
}
tifiles_content_delete_regular(src);
}
}
}
// Applications
if(local.selection2 != NULL)
{
for(ptr = local.selection2; ptr; ptr = ptr->next)
{
FileEntry *fe2 = ptr->data;
if(tifiles_file_is_app(fe2->name) || tifiles_file_test(fe2->name, TIFILE_OS, options.calc_model))
{
FileEntry *fe3 = g_memdup(ptr->data, sizeof(FileEntry));
fe3->content2 = tifiles_content_create_flash(options.calc_model);
err = tifiles_file_read_flash(fe2->name, fe3->content2);
if(err)
{
tifiles_content_delete_flash(fe3->content2);
g_free(fe3);
continue;
}
local.selection3 = g_list_append(local.selection3, fe3);
}
}
}
// Reparse variables and change target folder
if (local.selection1)
{
// replaced "" folder by "main"
if(!tifiles_has_folder(options.calc_model))
return;
for(ptr = local.selection1; ptr; ptr = ptr->next)
{
FileEntry *fe = ptr->data;
FileContent *fc = fe->content1;
unsigned int i;
if(fc == NULL)
continue;
for(i = 0; i < fc->num_entries; i++)
{
VarEntry *ve = (fc->entries)[i];
if(!strcmp(ve->folder , ""))
strcpy(ve->folder, "main");
}
}
}
}
/**
* tifiles_file_test:
* @filename: a filename as string.
* @type: type to check
* @target: hand-held model or CALC_NONE for no filtering
*
* Check whether #filename is a TI file of type #type useable on a #target model.
* This function is a generic one which overwrap and extends the tifiles_file_is_*
* functions.
*
* This is a powerful function which allows checking of a specific file type for
* a given target.
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_file_test(const char *filename, FileClass type, CalcModel target)
{
char *e = tifiles_fext_get(filename);
if (!tifiles_file_is_ti(filename))
return 0;
if (!strcmp(e, ""))
return 0;
if(target > CALC_MAX)
{
tifiles_critical("tifiles_file_test: invalid target argument! This is a bug.");
return 0;
}
if(type & TIFILE_SINGLE)
{
if(target && !g_ascii_strncasecmp(e, GROUP_FILE_EXT[target], 2))
return !0;
else
return tifiles_file_is_single(filename);
}
if(type & TIFILE_GROUP)
{
if(target && !g_ascii_strcasecmp(e, GROUP_FILE_EXT[target]))
return !0;
else
return tifiles_file_is_group(filename);
}
if(type & TIFILE_REGULAR)
{
return tifiles_file_test(filename, TIFILE_SINGLE, target) ||
tifiles_file_test(filename, TIFILE_GROUP, target);
}
if(type & TIFILE_BACKUP)
{
if(target && !g_ascii_strcasecmp(e, BACKUP_FILE_EXT[target]))
return !0;
else
return tifiles_file_is_backup(filename);
}
if(type & TIFILE_OS)
{
if(target && !g_ascii_strcasecmp(e, FLASH_OS_FILE_EXT[target]))
return !0;
else if(target && tifiles_file_is_tib(filename))
{
FILE *f;
uint8_t data[16];
f = g_fopen(filename, "rb");
if(f == NULL)
return 0;
fread_n_chars(f, 16, (char *)data);
fclose(f);
switch(data[8])
{
case 1: if(target != CALC_TI92P) return 0;
case 3: if(target != CALC_TI89) return 0;
case 8: if(target != CALC_V200) return 0;
case 9: if(target != CALC_TI89T) return 0;
}
return !0;
}
else
return tifiles_file_is_os(filename);
}
if(type & TIFILE_APP)
{
if(target && !g_ascii_strcasecmp(e, FLASH_APP_FILE_EXT[target]))
return !0;
else
return tifiles_file_is_app(filename);
}
if(type & TIFILE_FLASH)
{
return tifiles_file_test(filename, TIFILE_OS, target) ||
tifiles_file_test(filename, TIFILE_APP, target);
}
if(type & TIFILE_TIGROUP)
{
if(target)
{
// No easy/light way for this part: we have to load the whole file
// and to parse the TigEntry structures.
TigContent *content;
int ret, ok=0;
int k;
if(!tifiles_file_has_tig_header(filename))
return 0;
content = tifiles_content_create_tigroup(CALC_NONE, 0);
ret = tifiles_file_read_tigroup(filename, content);
if(ret) return 0;
for (k = 0; k < content->n_apps; k++)
{
TigEntry *te = content->app_entries[k];
if(tifiles_calc_are_compat(te->content.regular->model, target))
ok++;
}
for (k = 0; k < content->n_vars; k++)
{
TigEntry *te = content->var_entries[k];
if(tifiles_calc_are_compat(te->content.regular->model, target))
ok++;
}
tifiles_content_delete_tigroup(content);
return ok;
}
else
return tifiles_file_is_tigroup(filename);
}
return 0;
}
TIEXPORT2 int TICALL tifiles_file_is_tig(const char *filename)
{
return tifiles_file_is_tigroup(filename);
}
/**
* tifiles_file_get_icon:
* @filename: a filename as string.
*
* Returns the type of file (function, program, ...).
*
* Return value: a string like "Assembly Program" (non localized).
**/
TIEXPORT2 const char *TICALL tifiles_file_get_icon(const char *filename)
{
char *ext;
ext = tifiles_fext_get(filename);
if (!strcmp(ext, ""))
return "";
if (!g_ascii_strcasecmp(ext, "tib"))
return "OS upgrade";
if (!g_ascii_strcasecmp(ext, "tno") || !g_ascii_strcasecmp(ext, "tnc") || !g_ascii_strcasecmp(ext, "tco") || !g_ascii_strcasecmp(ext, "tcc"))
return "OS upgrade";
if (!tifiles_file_is_ti(filename))
return "";
if(tifiles_file_is_tigroup(filename))
return "TiGroup";
if (tifiles_file_is_group(filename))
{
switch (tifiles_file_get_model(filename))
{
case CALC_TI89:
case CALC_TI89T:
case CALC_TI89T_USB:
case CALC_TI92P:
case CALC_V200:
return "Group/Backup";
default:
return "Group";
}
}
switch (tifiles_file_get_model(filename))
{
#ifndef DISABLE_TI8X
case CALC_TI73:
return ti73_byte2icon(ti73_fext2byte(ext));
case CALC_TI82:
return ti82_byte2icon(ti82_fext2byte(ext));
case CALC_TI83:
return ti83_byte2icon(ti83_fext2byte(ext));
case CALC_TI83P:
case CALC_TI84P:
case CALC_TI84P_USB:
return ti83p_byte2icon(ti83p_fext2byte(ext));
case CALC_TI85:
return ti85_byte2icon(ti85_fext2byte(ext));
case CALC_TI86:
return ti86_byte2icon(ti86_fext2byte(ext));
#endif
#ifndef DISABLE_TI9X
case CALC_TI89:
case CALC_TI89T:
case CALC_TI89T_USB:
return ti89_byte2icon(ti89_fext2byte(ext));
case CALC_TI92:
return ti92_byte2icon(ti92_fext2byte(ext));
case CALC_TI92P:
return ti92p_byte2icon(ti92p_fext2byte(ext));
case CALC_V200:
return v200_byte2icon(v200_fext2byte(ext));
#endif
case CALC_NSPIRE:
return nsp_byte2icon(nsp_fext2byte(ext));
case CALC_NONE:
default:
return "";
break;
}
return "";
}
// The main function
int main(int argc, char **argv)
{
char *msg = NULL;
char buffer[256];
int i;
int ret;
// init library
tifiles_library_init();
// test tifiles.c
printf("Library version : <%s>\n", tifiles_version_get());
printf("--\n");
// test error.c
tifiles_error_get(515, &msg);
printf("Error message: <%s>\n", msg);
#ifndef __WIN32__
free(msg);
#endif
printf("--\n");
// test type2str.c
printf("tifiles_string_to_model: <%i> <%i>\n", CALC_TI92,
tifiles_string_to_model(tifiles_model_to_string(CALC_TI92)));
printf("tifiles_string_to_attribute: <%i> <%i>\n", ATTRB_LOCKED,
tifiles_string_to_attribute(tifiles_attribute_to_string(ATTRB_LOCKED)));
printf("tifiles_string_to_class: <%i> <%i>\n", TIFILE_SINGLE,
tifiles_string_to_class(tifiles_class_to_string(TIFILE_SINGLE)));
printf("--\n");
// test filetypes.c
for(i = CALC_TI73; i <= CALC_V200; i++)
{
printf("%s (%i) ", tifiles_fext_of_group(i), i);
}
printf("\n");
for(i = CALC_TI73; i <= CALC_V200; i++)
{
printf("%s ", tifiles_fext_of_backup(i));
}
printf("\n");
for(i = CALC_TI73; i <= CALC_V200; i++)
{
printf("%s ", tifiles_fext_of_flash_os(i));
}
printf("\n");
for(i = CALC_TI73; i <= CALC_V200; i++)
{
printf("%s ", tifiles_fext_of_flash_app(i));
}
printf("\n");
printf("--\n");
printf("<%s> <%s>\n", "foo.bar", tifiles_fext_get("foo.bar"));
ret = tifiles_file_is_ti(PATH("misc/str.92s"));
printf("tifiles_file_is_ti: %i\n", ret);
ret = tifiles_file_is_single(PATH("misc/str.92s"));
printf("tifiles_file_is_single: %i\n", ret);
ret = tifiles_file_is_group(PATH("misc/group.92g"));
printf("tifiles_file_is_group: %i\n", ret);
ret = tifiles_file_is_regular(PATH("misc/str.92s"));
printf("tifiles_file_is_regular: %i\n", ret);
ret = tifiles_file_is_regular(PATH("misc/group.92g"));
printf("tifiles_file_is_regular: %i\n", ret);
ret = tifiles_file_is_backup(PATH("misc/backup.83b"));
printf("tifiles_file_is_backup: %i\n", ret);
ret = tifiles_file_is_flash(PATH("misc/ticabfra.89k"));
printf("tifiles_file_is_flash: %i\n", ret);
ret = tifiles_file_is_flash(PATH("misc/TI73_OS160.73U"));
printf("tifiles_file_is_flash: %i\n", ret);
ret = tifiles_file_is_tib(PATH("misc/ams100.tib"));
printf("tifiles_file_is_tib: %i\n", ret);
ret = tifiles_file_is_tigroup(PATH("misc/test.tig"));
printf("tifiles_file_is_tigroup: %i\n", ret);
printf("--\n");
// test typesxx.c
printf("tifiles_file_get_model: %s\n",
tifiles_model_to_string(tifiles_file_get_model(PATH("misc/str.92s"))));
printf("tifiles_file_get_class: %s\n",
tifiles_class_to_string(tifiles_file_get_class(PATH("misc/group.92g"))));
printf("tifiles_file_get_type: %s\n",
tifiles_file_get_type(PATH("misc/TI73_OS160.73U")));
printf("tifiles_file_get_icon: %s\n",
tifiles_file_get_icon(PATH("misc/str.92s")));
printf("--\n");
// test misc.c
printf("tifiles_calc_is_ti8x: %i\n", tifiles_calc_is_ti8x(CALC_TI83));
printf("tifiles_calc_is_ti9x: %i\n", tifiles_calc_is_ti9x(CALC_TI89));
printf("tifiles_has_folder: %i\n", tifiles_has_folder(CALC_TI92));
printf("tifiles_is_flash: %i\n", tifiles_is_flash(CALC_TI73));
printf("tifiles_get_varname: <%s>\n", tifiles_get_varname("fld\\var"));
printf("tifiles_get_fldname: <%s>\n", tifiles_get_fldname("fld\\var"));
tifiles_build_fullname(CALC_TI89, buffer, "fld", "var");
printf("tifiles_build_fullname: <%s>\n", buffer);
printf("--\n");
// test filesxx.c & grouped.c
do
{
// TI73 support
change_dir(PATH("ti73"));
ret = test_ti73_backup_support(); if (ret) break;
ret = test_ti73_regular_support(); if (ret) break;
ret = test_ti73_group_support(); if (ret) break;
ret = test_ti73_ungroup_support(); if (ret) break;
// TI82 support
change_dir(PATH("ti82"));
ret = test_ti82_backup_support(); if (ret) break;
ret = test_ti82_regular_support(); if (ret) break;
ret = test_ti82_group_support(); if (ret) break;
ret = test_ti82_ungroup_support(); if (ret) break;
// TI83 support
change_dir(PATH("ti83"));
ret = test_ti83_backup_support(); if (ret) break;
ret = test_ti83_regular_support(); if (ret) break;
ret = test_ti83_group_support(); if (ret) break;
ret = test_ti83_ungroup_support(); if (ret) break;
// TI84+ support
change_dir(PATH("ti84p"));
ret = test_ti84p_regular_support(); if (ret) break;
ret = test_ti84p_group_support(); if (ret) break;
ret = test_ti84p_ungroup_support(); if (ret) break;
ret = test_ti84p_flash_support(); if (ret) break;
// TI85 support
change_dir(PATH("ti85"));
ret = test_ti85_regular_support(); if (ret) break;
// TI86 support
change_dir(PATH("ti86"));
ret = test_ti86_backup_support(); if (ret) break;
ret = test_ti86_regular_support(); if (ret) break;
ret = test_ti86_group_support(); if (ret) break;
ret = test_ti86_ungroup_support(); if (ret) break;
// TI89 support
change_dir(PATH("ti89"));
ret = test_ti89_regular_support(); if (ret) break;
ret = test_ti89_flash_support(); if (ret) break;
ret = test_v200_regular_support(); if (ret) break;
// TI92 support
change_dir(PATH("ti92"));
ret = test_ti92_backup_support(); if (ret) break;
ret = test_ti92_regular_support(); if (ret) break;
ret = test_ti92_group_support(); if (ret) break;
ret = test_ti92_ungroup_support(); if (ret) break;
// TIXX certificates
change_dir(PATH("certs"));
ret = test_ti8x_cert_support(); if (ret) break;
ret = test_ti9x_cert_support(); if (ret) break;
// Add/Del files
change_dir(PATH("misc"));
ret = test_ti8x_group_merge(); if (ret) break;
change_dir(PATH("tig"));
ret = test_tigroup();
} while(0);
// end of test
tifiles_library_exit();
return ret;
}
// Used for sending vars
// Note: user_data is a string:
// - such as "<FLASH>" for sending var into FLASH (ti83+/84+/89/92+/v200)
// - such as "" for sending var in the default folder
// - such as "foo" for sending var in the 'foo' folder
// - unused for sending FLASH files
void on_tilp_send(const gchar *user_data)
{
gchar *target;
FileEntry *f;
int ret1 = -1;
int ret2 = -1;
if (local.selection0 == NULL && local.selection2 == NULL && local.selection5 == NULL)
return;
tilp_local_contents_load();
// send apps
if(local.selection3 || (local.selection5 && local.selection3))
{
f = (FileEntry *) local.selection3->data;
// send os upgrades
if(tifiles_file_is_flash(f->name) || tifiles_file_is_tigroup(f->name))
{
if(tifiles_file_test(f->name, TIFILE_OS, options.calc_model))
{
if (tilp_calc_send_os(f->name) != 0)
return;
}
else if(tifiles_file_is_app(f->name))
{
ret1 = tilp_calc_send_app();
if(!ret1)
{
// update dirlist (caching, avoid to request dirlist again)
tilp_local_update_applist();
ctree_refresh();
labels_refresh();
}
}
}
}
// send vars
if(local.selection1 || (local.selection5 && local.selection1))
{
// note: dst_folder must be a copy b/c the user_data
// pointer is no longer valid after dirlist_remote
target = g_strdup(user_data);
// change target folder
if(strcmp(target, "") && strcmp(target, "<FLASH>"))
tilp_local_change_folder(target);
// and wait for action
if (display_action_dbox(target) == BUTTON2)
{
g_free(target);
tilp_local_contents_unload();
return;
}
// needed: avoid box locking/flickering !
GTK_REFRESH();
ret2 = tilp_calc_send_var();
if(!ret2)
{
// update dirlist (caching, avoid to request dirlist again)
tilp_local_update_varlist();
ctree_refresh();
labels_refresh();
}
g_free(target);
}
tilp_local_contents_unload();
}
void clist_refresh(void)
{
GtkTreeView *view = GTK_TREE_VIEW(clist_wnd);
GtkTreeSelection *selection;
GtkTreeViewColumn *col;
GtkTreeIter iter;
GdkPixbuf *pix1, *pix2, *pix;
GList *dirlist;
gsize br, bw;
gchar *utf8;
int i;
if(working_mode & MODE_CMD)
return;
// reparse folders
tilp_local_selection_destroy();
tilp_dirlist_local();
selection = gtk_tree_view_get_selection(view);
g_signal_handlers_block_by_func(G_OBJECT(selection), tree_selection_changed, NULL);
gtk_list_store_clear(list);
g_signal_handlers_unblock_by_func(G_OBJECT(selection), tree_selection_changed, NULL);
// sort files
for(i = 0; i < CLIST_NVCOLS; i++)
{
col = gtk_tree_view_get_column(view, i);
gtk_tree_view_column_set_sort_indicator(col, FALSE);
}
switch (options.local_sort)
{
case SORT_BY_NAME:
tilp_file_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.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
break;
case SORT_BY_TYPE:
tilp_file_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.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
break;
case SORT_BY_DATE:
tilp_file_sort_by_date();
col = gtk_tree_view_get_column(view, COLUMN_DATE);
gtk_tree_view_column_set_sort_indicator(col, TRUE);
gtk_tree_view_column_set_sort_order(col, options.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
break;
case SORT_BY_SIZE:
tilp_file_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.local_sort_order ? GTK_SORT_ASCENDING : GTK_SORT_DESCENDING);
break;
}
pix2 = gtk_widget_render_icon(GTK_WIDGET(view), GTK_STOCK_DIRECTORY, GTK_ICON_SIZE_MENU, NULL);
pix1 = gtk_widget_render_icon(GTK_WIDGET(view), GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU, NULL);
for (dirlist = local.dirlist; dirlist != NULL; dirlist = dirlist->next)
{
FileEntry *fe = (FileEntry *) dirlist->data;
gboolean b;
CalcModel s = tifiles_file_get_model(fe->name);
CalcModel t = options.calc_model;
b = options.show_all || S_ISDIR(fe->attrib) ||
tifiles_file_is_tib(fe->name) ||
#if 0
tifiles_file_is_tigroup(fe->name) ||
#else
tifiles_file_test(fe->name, TIFILE_TIGROUP, options.calc_model) ||
#endif
tifiles_calc_are_compat(s, t);
if(!b)
continue;
if (S_ISDIR(fe->attrib))
{
pix = strcmp(fe->name, "..") ? pix2 : pix1;
}
else
{
char icon_name[2048];
strcpy(icon_name, tifiles_file_get_icon(fe->name));
if (!strcmp(icon_name, ""))
strcpy(icon_name, "TIicon1");
strcat(icon_name, ".ico");
tilp_file_underscorize(icon_name);
pix = create_pixbuf(icon_name);
}
// filenames are stored in the 'glib filename encoding' and GTK+ uses utf8
utf8 = g_filename_to_utf8(fe->name, -1, &br, &bw, NULL);
gtk_list_store_append(list, &iter);
gtk_list_store_set(list, &iter,
COLUMN_NAME, utf8,
COLUMN_TYPE, tilp_file_get_type(fe),
COLUMN_SIZE, tilp_file_get_size(fe),
COLUMN_DATE, tilp_file_get_date(fe),
COLUMN_DATA, (gpointer) fe,
COLUMN_ICON, pix,
-1);
g_free(utf8);
}
g_object_unref(pix1);
g_object_unref(pix2);
}
