/**
* tifiles_calc_are_compat:
* @model: a calculator model.
* @ref: a calculator model.
*
* Check whether %model is compatible (in term of file types) with %ref.
* Example: a .92t can be sent to a TI92 (of course) as well as a
* TI89, 92+, V200 and a Titanium.
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_calc_are_compat(CalcModel model, CalcModel ref)
{
if(tifiles_calc_is_ti8x(model) && tifiles_calc_is_ti8x(ref))
return !0;
else if(tifiles_calc_is_ti9x(model) && tifiles_calc_is_ti9x(ref))
return !0;
else if((model == CALC_NSPIRE) && (ref == CALC_NSPIRE))
return !0;
return 0;
}
/**
* ticalcs_clock_format2date:
* @model: a calculator model
* @value: a format type
*
* Convert a format type into a format string.
* Example: 1 -> "MM/DD/YY"
*
* Return value: a format string.
**/
TIEXPORT3 const char *TICALL ticalcs_clock_format2date(CalcModel model, int value)
{
int v;
if(tifiles_calc_is_ti9x(model))
{
if (value < 1)
v = 1;
else if (value > MAX_FORMAT_89)
v = MAX_FORMAT_89;
else
v = value;
return TI_CLOCK_89[v];
}
else if(tifiles_calc_is_ti8x(model))
{
if (value < 1)
v = 1;
else if (value > MAX_FORMAT_84)
v = MAX_FORMAT_84;
else
v = value;
return TI_CLOCK_84[v];
}
return "";
}
/**
* tifiles_file_read_flash:
* @filename: name of FLASH file to open.
* @content: where to store the file content.
*
* Load the FLASH file into a FlashContent structure.
*
* Structure content must be freed with #tifiles_content_delete_flash when
* no longer used.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int tifiles_file_read_flash(const char *filename, FlashContent *content)
{
if (filename == NULL || content == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(tifiles_file_get_model(filename)))
return ti8x_file_read_flash(filename, content);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(tifiles_file_get_model(filename)) || tifiles_file_is_tib(filename))
return ti9x_file_read_flash(filename, content);
else
#endif
if(content->model == CALC_NSPIRE)
return tnsp_file_read_flash(filename, content);
else
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_content_create_flash:
* @model: a calculator model (compulsory).
*
* Allocates a #FlashContent structure.
*
* Return value: the allocated block.
**/
TIEXPORT2 FlashContent* TICALL tifiles_content_create_flash(CalcModel model)
{
FlashContent* content = g_malloc0(sizeof(FlashContent));
if (content != NULL)
{
content->model = model;
if(tifiles_calc_is_ti9x(content->model))
{
time_t tt;
struct tm *lt;
time(&tt);
lt = localtime(&tt);
content->revision_major = 1;
content->revision_minor = 0;
content->flags = 0;
content->object_type = 0;
content->revision_day = lt->tm_mday;
content->revision_month = lt->tm_mon;
content->revision_year = lt->tm_year + 1900;
}
}
return content;
}
/**
* tifiles_file_display_regular:
* @content: the file content to show.
*
* Display file content information.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int TICALL tifiles_file_display_regular(FileContent *content)
{
if (content == NULL)
{
tifiles_critical("%s(NULL)", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(content->model))
return ti8x_content_display_regular(content);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(content->model))
return ti9x_content_display_regular(content);
else
#endif
if(content->model == CALC_NSPIRE)
return tnsp_content_display_regular(content);
else
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_file_write_regular:
* @filename: name of single/group file where to write or NULL.
* @content: the file content to write.
* @real_fname: pointer address or NULL. Must be freed if needed when no longer needed.
*
* Write one (or several) variable(s) into a single (group) file. If filename is set to NULL,
* the function build a filename from varname and allocates resulting filename in %real_fname.
* %filename and %real_filename can be NULL but not both !
*
* %real_filename must be freed when no longer used.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int tifiles_file_write_regular(const char *filename, FileContent *content, char **real_fname)
{
if (content == NULL || (filename == NULL && real_fname == NULL))
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(content->model))
return ti8x_file_write_regular(filename, (Ti8xRegular *)content, real_fname);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(content->model))
return ti9x_file_write_regular(filename, (Ti9xRegular *)content, real_fname);
else
#endif
if(content->model == CALC_NSPIRE)
return tnsp_file_write_regular(filename, (FileContent *)content, real_fname);
else
return ERR_BAD_CALC;
return 0;
}
/**
* ticalcs_clock_date2format:
* @model: a calculator model
* @format: a format string
*
* Convert a format string into a format type.
* Example: "MM/DD/YY" -> 1
*
* Return value: a format string.
**/
TIEXPORT3 int TICALL ticalcs_clock_date2format(CalcModel model, const char *format)
{
int i = 1;
if (format == NULL)
{
ticalcs_critical("ticalcs_clock_date2format: format is NULL");
return 0;
}
if(tifiles_calc_is_ti9x(model))
{
for (i = 1; i <= MAX_FORMAT_89; i++)
{
if (!strcasecmp(TI_CLOCK_89[i], format))
break;
}
if (i > MAX_FORMAT_89)
return 1;
}
else if(tifiles_calc_is_ti8x(model))
{
for (i = 1; i <= MAX_FORMAT_84; i++)
{
if (!strcasecmp(TI_CLOCK_84[i], format))
break;
}
if (i > MAX_FORMAT_84)
return 1;
}
return i;
}
/**
* tifiles_calc_are_compat:
* @model: a calculator model.
* @ref: a calculator model.
*
* Check whether %model is compatible (in term of file types) with %ref.
* Example: a .92t can be sent to a TI92 (of course) as well as a
* TI89, 92+, V200 and a Titanium.
*
* Return value: a boolean value.
**/
TIEXPORT2 int TICALL tifiles_calc_are_compat(CalcModel model, CalcModel ref)
{
if (tifiles_calc_is_ti8x(model) && tifiles_calc_is_ti8x(ref))
{
return !0;
}
else if (tifiles_calc_is_ti9x(model) && tifiles_calc_is_ti9x(ref))
{
return !0;
}
else if (ticonv_model_is_tinspire(model) && ticonv_model_is_tinspire(ref))
{
return !0;
}
return 0;
}
/**
* tifiles_content_dup_flash:
*
* Allocates and copies a new FlashContent structure.
*
* Return value: none.
**/
TIEXPORT2 FlashContent* TICALL tifiles_content_dup_flash(FlashContent *content)
{
FlashContent *dup = NULL;
FlashContent *p, *q;
if (content != NULL)
{
dup = tifiles_content_create_flash(content->model);
if (dup != NULL)
{
for(p = content, q = dup; p; p = p->next, q = q->next)
{
memcpy(q, p, sizeof(FlashContent));
// TI9x part
if(tifiles_calc_is_ti9x(content->model))
{
if(p->data_part)
{
q->data_part = (uint8_t *)g_malloc0(p->data_length+1);
memcpy(q->data_part, p->data_part, p->data_length+1);
}
}
// TI8x part
if(tifiles_calc_is_ti8x(content->model))
{
int i;
// copy pages
q->pages = tifiles_fp_create_array(p->num_pages);
for(i = 0; i < content->num_pages; i++)
{
q->pages[i] = (FlashPage *)g_malloc0(sizeof(FlashPage));
memcpy(q->pages[i], p->pages[i], sizeof(FlashPage));
q->pages[i]->data = (uint8_t *) g_malloc0(p->pages[i]->size);
memcpy(q->pages[i]->data, p->pages[i]->data, p->pages[i]->size);
}
}
if(p->next)
q->next = tifiles_content_create_flash(p->model);
}
}
}
else
{
tifiles_critical("%s(NULL)", __FUNCTION__);
}
return dup;
}
/**
* 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;
}
gint display_debug_dbox(void)
{
const gchar *filename;
const gchar *ext;
static gchar *folder = NULL;
// set mask
switch(tihw.calc_type)
{
case TI92:
ext = "*.92?";
break;
default:
ext = "*.89?;*.92?;*.9x?;*.v2?";
break;
}
// get filename
if(folder == NULL)
folder = g_strdup(inst_paths.base_dir);
filename = (char *)create_fsel(folder, NULL, (char *)ext, FALSE);
if (!filename)
{
return 0;
}
// keep folder
g_free(folder);
folder = g_path_get_dirname(filename);
// check extension
if(!tifiles_file_is_ti(filename) ||
!tifiles_calc_is_ti9x(tifiles_file_get_model(filename)))
{
msg_box1(_("Error"), _("This file is not a valid TI file."));
return -1;
}
fs_send_file_and_debug_info(filename);
return 0;
}
GLADE_CB void
qs_filechooserbutton1_current_folder_changed
(GtkFileChooser *filechooser,
gpointer user_data)
{
gchar *fname = gtk_file_chooser_get_filename (filechooser);
if(!fname)
return;
if(!tifiles_file_is_ti(fname) || !tifiles_calc_is_ti9x(tifiles_file_get_model(fname)) ||
!tifiles_file_test(fname, TIFILE_REGULAR, CALC_NONE))
{
g_free(tmp_file); tmp_file = NULL;
msg_box1(_("Error"), _("This file is not a valid TI file."));
return;
}
g_free(tmp_file);
tmp_file = g_strdup(fname); // dup or copy???
}
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;
}
/**
* tifiles_file_write_backup:
* @filename: name of backup file where to write.
* @content: the file content to write.
*
* Write backup into file.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int tifiles_file_write_backup(const char *filename, BackupContent *content)
{
if (filename == NULL || content == NULL)
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(content->model))
return ti8x_file_write_backup(filename, content);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(content->model))
return ti9x_file_write_backup(filename, content);
else
#endif
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_file_write_flash2:
* @filename: name of flash file where to write or NULL.
* @content: the file content to write.
* @real_fname: pointer address or NULL. Must be freed if needed when no longer needed.
*
* Write a FLASH content to a file. If filename is set to NULL, the function build a filename
* from appname and allocates resulting filename in %real_fname.
* %filename and %real_fname can be NULL but not both !
*
* %real_fname must be freed when no longer used.
*
* Return value: an error code, 0 otherwise.
**/
TIEXPORT2 int tifiles_file_write_flash2(const char *filename, FlashContent *content, char **real_fname)
{
if (content == NULL || (filename == NULL && real_fname == NULL))
{
tifiles_critical("%s: an argument is NULL", __FUNCTION__);
return ERR_INVALID_FILE;
}
#if !defined(DISABLE_TI8X)
if (tifiles_calc_is_ti8x(content->model))
return ti8x_file_write_flash(filename, content, real_fname);
else
#endif
#if !defined(DISABLE_TI9X)
if (tifiles_calc_is_ti9x(content->model))
return ti9x_file_write_flash(filename, content, real_fname);
else
#endif
return ERR_BAD_CALC;
return 0;
}
/**
* tifiles_content_delete_backup:
*
* Free the whole content of a BackupContent structure.
*
* Return value: none.
**/
TIEXPORT2 int TICALL tifiles_content_delete_backup(BackupContent *content)
{
if (content != NULL)
{
if (tifiles_calc_is_ti9x(content->model))
g_free(content->data_part);
else if (tifiles_calc_is_ti8x(content->model))
{
g_free(content->data_part1);
g_free(content->data_part2);
g_free(content->data_part3);
g_free(content->data_part4);
}
g_free(content);
}
else
{
tifiles_critical("%s(NULL)", __FUNCTION__);
}
return 0;
}
int rd_dump(CalcHandle* h, const char *filename)
{
FILE *f;
CalcHandle* handle = h;
int err = 0;
uint32_t size;
uint32_t addr;
uint16_t length;
uint32_t i;
uint8_t data[65536];
f = fopen(filename, "wb");
if (f == NULL)
return ERR_OPEN_FILE;
sprintf(update_->text, "Receiving data...");
update_label();
// check if ready
for(i = 0; i < 3; i++)
{
err = rom_send_RDY(h);
TRYF(rom_recv_RDY(h));
if(!err)
break;
}
// request ROM size
TRYF(rom_send_SIZE(h));
TRYF(rom_recv_SIZE(h, &size));
// get packets
std_blk = sav_blk = 0;
for(addr = 0x0000; addr < size; )
{
if(err == ERR_ABORT)
goto exit;
// resync if error
if(err)
{
PAUSE(500);
for(i = 0; i < MAX_RETRY; i++)
{
err = rom_send_RDY(h);
if(err) continue;
err = rom_recv_RDY(h);
if(err) continue;
}
if(i == MAX_RETRY && err)
goto exit;
err = 0;
}
if(tifiles_calc_is_ti9x(h->model) && addr >= 0x10000 && addr < 0x12000)
{
// certificate is read protected: skip
memset(data, 0xff, length);
if (fwrite(data, length, 1, f) < 1)
return ERR_SAVE_FILE;
addr += length;
continue;
}
// receive data
err = rom_send_DATA(h, addr);
if(err) continue;
err = rom_recv_DATA(h, &length, data);
if(err) continue;
if (fwrite(data, length, 1, f) < 1)
return ERR_SAVE_FILE;
addr += length;
update_->cnt2 = addr;
update_->max2 = size;
update_->pbar();
}
ticalcs_info("Saved %i blocks on %i blocks\n", sav_blk, sav_blk + std_blk);
// finished
exit:
if(h->model == CALC_TI83P || h->model == CALC_TI84P)
{
//TRYF(ti73_recv_ACK(NULL)); // ACK sent after ENTER key when dumper exits
}
PAUSE(200);
TRYF(rom_send_EXIT(h));
TRYF(rom_recv_EXIT(h));
PAUSE(1000);
fclose(f);
return err;
}
/**
* ticonv_utf16_to_gfe:
* @model: a calculator model taken in #CalcModel.
* @src: the name of variable to convert from UTF-16
*
* This function converts a varname into a valid filename (depends on locale).
* Example: 'foobar' => foobar, 'alpha' => _alpha_.
*
* Greeks characters need conversion if the locale is not UTF-8 (Windows for sure, Linux
* if locale is different of UTF-8) because greek characters are often missed or mis-converted
* when converting to locale.
*
* Return value: %dst as a newly allocated string.
**/
TIEXPORT4 char* TICALL ticonv_utf16_to_gfe(CalcModel model, const unsigned short *src)
{
#ifdef __WIN32__
int is_utf8 = G_WIN32_HAVE_WIDECHAR_API();
#else
int is_utf8 = g_get_charset(NULL);
#endif
const char *str;
unsigned short *utf16_src, *p;
unsigned short *utf16_dst, *q;
char *dst;
// detokenization to UTF-16
p = utf16_src = (unsigned short *)src;
q = utf16_dst = g_malloc0(18*ticonv_utf16_strlen(utf16_src)+2);
// conversion from UTF-16 to UTF-16
if(tifiles_calc_is_ti9x(model) && !is_utf8)
{
while(*p)
{
unsigned long msb = *p & 0xff00;
if(!msb)
{
*q++ = *p++ & 0xff;
}
else
{
gunichar2 *str2;
glong ir, iw;
switch(*p)
{
case 0x03bc: str = "_mu_"; break;
case 0x03b1: str = "_alpha_"; break;
case 0x03b2: str = "_beta_"; break;
case 0x0393: str = "_GAMMA_"; break;
case 0x03b3: str = "_gamma_"; break;
case 0x0394: str = "_DELTA_"; break;
case 0x03b4: str = "_delta_"; break;
case 0x03b5: str = "_epsilon_";break;
case 0x03b6: str = "_zeta_"; break;
case 0x03b8: str = "_theta_"; break;
case 0x03bb: str = "_lambda_"; break;
case 0x03be: str = "_ksi_"; break;
case 0x03a0: str = "_PI_"; break;
case 0x03c0: str = "_pi_"; break;
case 0x03c1: str = "_rho_"; break;
case 0x03a3: str = "_SIGMA_"; break;
case 0x03c3: str = "_sigma_"; break;
case 0x03c4: str = "_tau_"; break;
case 0x03d5: str = "_PHI_"; break;
case 0x03a8: str = "_PSI_"; break;
case 0x03a9: str = "_OMEGA_"; break;
case 0x03c9: str = "_omega_"; break;
default: str = ""; break;
}
str2 = g_utf8_to_utf16(str, -1, &ir, &iw, NULL);
memcpy(q, str2, (iw+1) * sizeof(unsigned short));
g_free(str2);
q += iw;
p++;
}
}
*q = '\0';
}
else if(tifiles_calc_is_ti8x(model) && !is_utf8)
{
while(*p)
{
unsigned long msb = *p & 0xff00;
if(!msb)
{
*q++ = *p++ & 0xff;
}
else
{
if(*p >= 0x2080 && *p <= 0x2089)
{
*q++ = (*p++ - 0x2080) + '0';
}
else
{
gunichar2 *str2;
glong ir, iw;
switch(*p)
{
case 0x03bc: str = "_mu_"; break;
case 0x03b1: str = "_alpha_"; break;
case 0x03b2: str = "_beta_"; break;
case 0x0393: str = "_GAMMA_"; break;
case 0x03b3: str = "_gamma_"; break;
case 0x0394: str = "_DELTA_"; break;
case 0x03b4: str = "_delta_"; break;
case 0x03b5: str = "_epsilon_";break;
case 0x03b6: str = "_zeta_"; break;
case 0x03b8: str = "_theta_"; break;
case 0x03bb: str = "_lambda_"; break;
case 0x03be: str = "_ksi_"; break;
case 0x03a0: str = "_PI_"; break;
case 0x03c0: str = "_pi_"; break;
case 0x03c1: str = "_rho_"; break;
case 0x03a3: str = "_SIGMA_"; break;
case 0x03c3: str = "_sigma_"; break;
case 0x03c4: str = "_tau_"; break;
case 0x03d5: str = "_PHI_"; break;
case 0x03a8: str = "_PSI_"; break;
case 0x03a9: str = "_OMEGA_"; break;
case 0x03c9: str = "_omega_"; break;
default: str = ""; break;
}
str2 = g_utf8_to_utf16(str, -1, &ir, &iw, NULL);
memcpy(q, str2, (iw+1) * sizeof(gunichar2));
g_free(str2);
q += iw;
p++;
}
}
}
*q = '\0';
}
else
{
while(*p)
{
#ifdef __WIN32__
if(*p >= 0x2080 && *p <= 0x2089)
{
*q++ = (*p++ - 0x2080) + '0';
}
else
#endif
*q++ = *p++;
}
*q = '\0';
}
// '/' is not allowed in filenames
for(q = utf16_dst; *q; q++)
{
if(*q == '/')
*q = '_';
}
// UTF-16 to UTF-8 to GFE encoding
{
gchar *utf8;
utf8 = g_utf16_to_utf8(utf16_dst, -1, NULL, NULL, NULL);
g_free(utf16_dst);
dst = g_filename_from_utf8(utf8, -1, NULL, NULL, NULL);
g_free(utf8);
}
return dst;
}
// 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;
}
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);
}
