31#include <system_threads.h>
34#include <libFreeWRL.h>
36#include "vrml_parser/Structs.h"
37#include "input/InputFunctions.h"
38#include "opengl/OpenGL_Utils.h"
39#include "opengl/Textures.h"
40#include "opengl/LoadTextures.h"
53static void possiblyUnzip (openned_file_t *of);
55void close_openned_file(openned_file_t *file);
59 resource_item_t *lastBaseResource;
61void *resources_constructor()
67void resources_init(
struct tresources* t)
72 t->prv = resources_constructor();
75void resources_clear(
struct tresources* t)
81 deleteVector(
void *,p->resStack);
88resource_item_t *newResourceItem() {
89 resource_item_t *item = XALLOC(resource_item_t);
92 item->media_type = resm_unknown;
93 item->type = rest_invalid;
94 item->status = ress_invalid;
96 item->actual_file = NULL;
97 item->cached_files = NULL;
116static void resource_tree_append(resource_item_t *item){
118 pthread_mutex_lock( &gglobal()->threads.mutex_resource_tree );
120 if (!gglobal()->resources.root_res) {
122 gglobal()->resources.root_res = (
void*)item;
123 DEBUG_RES(
"setting root_res in resource_create_single for file %s\n",request);
126 ((resource_item_t*)gglobal()->resources.root_res)->children = ml_append(((resource_item_t*)gglobal()->resources.root_res)->children, ml_new(item));
127 item->parent = (resource_item_t*)gglobal()->resources.root_res;
131 pthread_mutex_unlock( &gglobal()->threads.mutex_resource_tree );
134resource_item_t* resource_create_single0(
const char *request)
136 resource_item_t *item;
137 DEBUG_RES(
"creating resource: SINGLE: %s\n", request);
139 item = newResourceItem();
140 item->URLrequest = STRDUP(request);
141 item->_loadThread = NULL;
145resource_item_t* resource_create_single(
const char *request)
147 resource_item_t *item = resource_create_single0(request);
148 resource_tree_append(item);
157resource_item_t* resource_create_multi0(
const s_Multi_String_t *request)
161 resource_item_t *item;
162 DEBUG_RES(
"creating resource: MULTI: %d, %s ...\n", request->n, request->p[0]->strptr);
163 item = newResourceItem();
166 item->type = rest_multi;
170 for (i = 0; i < request->n; i++) {
171 char *url = STRDUP(request->p[i]->strptr);
173 item->m_request = ml_append(item->m_request, ml_new(url));
177resource_item_t* resource_create_multi(
const s_Multi_String_t *request)
179 resource_item_t *item = resource_create_multi0(request);
180 resource_tree_append(item);
189resource_item_t* resource_create_from_string(
const char *
string)
191 resource_item_t *item;
192 DEBUG_RES(
"creating resource: STRING: %s\n",
string);
193 item = newResourceItem();
196 item->URLrequest = STRDUP(
string);
197 item->type = rest_string;
198 item->status = ress_loaded;
200 resource_tree_append(item);
214bool checkNetworkFile(
const char *fn)
220 ConsoleMessage (
"checkNetworkFile, got a NULL here");
232 if ((strncmp(fn,
"ftp://", strlen(
"ftp://"))) &&
233 (strncmp(fn,
"FTP://", strlen(
"FTP://"))) &&
234 (strncmp(fn,
"http://", strlen(
"http://"))) &&
235 (strncmp(fn,
"HTTP://", strlen(
"HTTP://"))) &&
236 (strncmp(fn,
"https://", strlen(
"https://"))) &&
237 (strncmp(fn,
"HTTPS://", strlen(
"HTTPS://"))) &&
242 (strncmp(fn,
"urn://", strlen(
"urn://"))) &&
243 (strncmp(fn,
"URN://", strlen(
"URN://")))
274 static int res_id_error_once = 0;
275void resource_identify(resource_item_t *baseResource, resource_item_t *res)
280 resource_item_t *defaults = NULL;
283 DEBUG_RES(
"resource_identify, we have resource %s ptrs %p and %p\n",res->URLrequest,baseResource,baseResource);
286 DEBUG_RES(
" base specified, taking the base values.\n");
287 defaults = baseResource;
288 res->parent = baseResource;
291 DEBUG_RES(
" no base specified, taking parent's values.\n");
292 defaults = res->parent;
294 DEBUG_RES(
" no base neither parent, no default values.\n");
299 DEBUG_RES(
" default values: network=%s type=%s status=%s"
300 " URLrequest=<%s> URLbase=<%s>parsed_request=<%s> [parent %p, %s]\n",
301 BOOL_STR(defaults->network), resourceTypeToString(defaults->type),
302 resourceStatusToString(defaults->status), defaults->URLrequest,
303 defaults->URLbase, defaults->parsed_request,
304 defaults->parent, (defaults->parent ? defaults->parent->URLbase :
"N/A")
308 if (res->type == rest_multi) {
310 if (res->m_request) {
314 FREE_IF_NZ(res->URLrequest);
315 res->URLrequest = (
char *) l->elem;
317 res->m_request = res->m_request->next;
321 if(!res_id_error_once)
322 ERROR_MSG(
"resource_identify: ERROR: empty multi string as input\n");
330 network = defaults->network;
336 pound = strchr(res->URLrequest,
'#');
341 res->afterPoundCharacters = STRDUP(pound);
345 res->network = checkNetworkFile(res->URLrequest);
347 DEBUG_RES(
"resource_identify: base network / resource network: %s/%s\n",
349 BOOL_STR(res->network));
352 if (res->network || network) {
357 res->type = rest_url;
358 res->status = ress_starts_good;
359 url = STRDUP(res->URLrequest);
371 cleanedURL = stripLocalFileName(res->URLrequest);
374 IF_cleanedURL_IS_ABSOLUTE {
377 url = STRDUP(cleanedURL);
380 cwd = STRDUP(defaults->URLbase);
381 url = concat_path(cwd, cleanedURL);
385 res->type = rest_url;
386 res->status = ress_starts_good;
388 res->type = rest_invalid;
389 ERROR_MSG(
"resource_identify: can't handle relative url without base: %s\n", res->URLrequest);
395 DEBUG_RES(
"resource_identify, we may have a local file for resource %s\n", res->URLrequest);
398 len = strlen(res->URLrequest);
399 if (len > PATH_MAX) {
401 res->type = rest_invalid;
403 ERROR_MSG(
"resource_identify: path too long: %s\n", res->URLrequest);
406 char *cleanedURL = NULL;
410 cleanedURL = stripLocalFileName(res->URLrequest);
415 IF_cleanedURL_IS_ABSOLUTE {
418 res->type = rest_file;
419 res->status = ress_starts_good;
420 url = STRDUP(cleanedURL);
423 cwd = STRDUP(defaults->URLbase);
424 res->type = rest_file;
425 res->status = ress_starts_good;
426 url = concat_path(cwd, cleanedURL);
433 IF_cleanedURL_IS_ABSOLUTE {
436 res->type = rest_file;
437 res->status = ress_starts_good;
438 url = STRDUP(cleanedURL);
444 cwd = get_current_dir();
445 removeFilenameFromPath(cwd);
450 url = concat_path(cwd, res->URLrequest);
451 res->type = rest_file;
452 res->status = ress_starts_good;
459 FREE_IF_NZ(res->parsed_request);
460 res->parsed_request = url;
461 FREE_IF_NZ(res->URLbase);
462 res->URLbase = STRDUP(url);
463 removeFilenameFromPath(res->URLbase);
467 DEBUG_RES(
"resource_identify (end): network=%s type=%s status=%s"
468 " request=<%s> base=<%s> url=<%s> [parent %p, %s]\n",
469 BOOL_STR(res->network), resourceTypeToString(res->type),
470 resourceStatusToString(res->status), res->URLrequest,
471 res->URLbase, res->parsed_request,
472 res->parent, (res->parent ? res->parent->URLbase :
"N/A"));
475textureTableIndexStruct_s *getTableIndex(
int i);
476bool imagery_load(resource_item_t *res){
480 textureNumber = res->textureNumber;
481 if(res->status == ress_downloaded){
482 entry = getTableIndex(textureNumber);
484 if (texture_load_from_file(entry, res->actual_file)) {
485 entry->status = TEX_READ;
486 res->status = ress_loaded;
491 res->status = ress_not_loaded;
499bool resource_load(resource_item_t *res)
501 openned_file_t *of = NULL;
505 DEBUG_RES(
"loading resource: %s, %s\n", resourceTypeToString(res->type), resourceStatusToString(res->status));
509 switch (res->status) {
511 case ress_starts_good:
514 ERROR_MSG(
"resource_load: can't load not available resource: %s\n", res->URLrequest);
519 case ress_downloaded:
521 of = load_file(res->actual_file);
524 res->status = ress_loaded;
526 res->openned_files = of;
529 if (res->media_type == resm_unknown) {
530 resource_identify_type(res);
535 res->status = ress_not_loaded;
536 ERROR_MSG(
"resource_load: can't load file: %s\n", res->actual_file);
542 ERROR_MSG(
"resource_load: MISTAKE: can't load already loaded resource: %s\n", res->URLrequest);
545 case ress_not_loaded:
546 ERROR_MSG(
"resource_load: loader already failed for this resource: %s\n", res->URLrequest);
550 ERROR_MSG(
"resource_load: MISTAKE: can't load resource already parsed: %s\n", res->URLrequest);
553 case ress_not_parsed:
554 ERROR_MSG(
"resource_load: MISTAKE: can't load resource already parsed (and failed): %s\n", res->URLrequest);
561#define strcasecmp stricmp
567void resource_identify_type(resource_item_t *res)
569 char *test_it = NULL;
576 if (res->media_type != resm_unknown)
580 switch (res->status) {
584 ERROR_MSG(
"can't identify type for invalid resource: %s\n", res->URLrequest);
588 test_it = (
char*)res->URLrequest;
589 ConsoleMessage (
"test_it is :%s:",test_it);
590 test_it_len = (int)strlen(res->URLrequest);
602 of = res->openned_files;
609 char *sourcename = (
char *)of->fileFileName;
610 if(res->type == rest_url) sourcename = res->URLrequest;
611 if(!strcmp(&sourcename[strlen(sourcename)-4],
".x3z")){
612 res->media_type = resm_x3z;
616 if(!strcasecmp(&sourcename[strlen(sourcename)-5],
".glTF")){
618 res->media_type = resm_gltf;
621 if(!strcasecmp(&sourcename[strlen(sourcename)-4],
".glb")){
623 res->media_type = resm_glb;
626 if(!strcasecmp(&sourcename[strlen(sourcename)-4],
".bin")){
628 res->media_type = resm_bin;
634 if(!strcasecmp(&sourcename[strlen(sourcename)-4],
".json")){
635 res->media_type = resm_json;
638 if(!strcasecmp(&sourcename[strlen(sourcename)-4],
".b3dm")){
639 res->media_type = resm_b3dm;
642 if(!strcasecmp(&sourcename[strlen(sourcename)-4],
".i3dm")){
643 res->media_type = resm_i3dm;
646 if(!strcasecmp(&sourcename[strlen(sourcename)-4],
".pnts")){
647 res->media_type = resm_pnts;
650 if(!strcasecmp(&sourcename[strlen(sourcename)-4],
".cmpt")){
651 res->media_type = resm_cmpt;
657 test_it = of->fileData;
658 test_it_len = of->fileDataSize;
665 if(memcmp(test_it,
"glTF",4)){
667 res->media_type = resm_glb;
669 t = determineFileType(test_it,test_it_len);
674#if defined (INCLUDE_STL_FILES)
675 case IS_TYPE_BINARY_STL:
case IS_TYPE_ASCII_STL:
679 res->media_type = resm_vrml;
682#if defined (INCLUDE_NON_WEB3D_FORMATS)
683 case IS_TYPE_COLLADA:
685 case IS_TYPE_SKETCHUP:
688 case IS_TYPE_XML_X3D:
689 res->media_type = resm_x3d;
703void remove_file_or_folder(
const char *path);
705void resource_remove_cached_file(s_list_t *cfe)
707 const char *cached_file;
708 cached_file = (
const char *) cfe->elem;
711 remove_file_or_folder(cached_file);
720void _resourceFreeCallback(
void *resource);
722void resource_destroy(resource_item_t *res)
727 DEBUG_RES(
"destroying resource: %d, %d\n", res->type, res->status);
736 switch (res->status) {
738 case ress_starts_good:
743 case ress_downloaded:
746 case ress_not_loaded:
748 case ress_not_parsed:
759 cf = (s_list_t *) res->cached_files;
764 ml_foreach(cf, resource_remove_cached_file(__l));
768 FREE_IF_NZ(res->actual_file);
773 FREE_IF_NZ(res->parsed_request);
777 switch (res->status) {
779 case ress_starts_good:
784 case ress_downloaded:
787 case ress_not_loaded:
789 case ress_not_parsed:
797 FREE(res->actual_file);
802 FREE_IF_NZ(res->parsed_request);
815 ml_delete_all2(res->m_request, (void (*)(
void *))ml_free);
816 res->m_request = NULL;
818 FREE_IF_NZ(res->URLbase);
819 FREE_IF_NZ(res->afterPoundCharacters);
820 FREE_IF_NZ(res->openned_files);
829 FREE_IF_NZ(res->URLrequest);
833void resource_unlink_cachedfiles(resource_item_t *res)
838 DEBUG_RES(
"destroying resource: %d, %d\n", res->type, res->status);
843 cf = (s_list_t *) res->cached_files;
848 ml_foreach(cf, resource_remove_cached_file(__l));
853void resource_close_files(resource_item_t *res)
857 DEBUG_RES(
"closing resource file: %d, %d\n", res->type, res->status);
869void resource_remove_child(resource_item_t *parent, resource_item_t *child)
877 cf = ml_find_elem(parent->children, child);
880 ml_delete(parent->children, cf);
887void destroy_root_res()
889 resource_destroy((resource_item_t*)gglobal()->resources.root_res);
890 gglobal()->resources.root_res = NULL;
893void resource_tree_destroy()
895 resource_item_t* root;
896 root = (resource_item_t*)gglobal()->resources.root_res;
898 ml_foreach(root->children,resource_close_files((resource_item_t*)ml_elem(__l)));
899 ml_foreach(root->children,resource_unlink_cachedfiles((resource_item_t*)ml_elem(__l)));
900 ml_foreach(root->children,resource_destroy((resource_item_t*)ml_elem(__l)));
901 ml_foreach(root->children,resource_remove_child(root,(resource_item_t*)ml_elem(__l)));
902 ml_foreach(root->children,ml_free(__l));
903 resource_close_files(root);
904 resource_unlink_cachedfiles(root);
912void resource_dump(resource_item_t *res)
919 PRINTF (
"resource_dump: %p\n"
921 "parsed request: %s\n"
924 res, res->URLrequest, res->parsed_request, res->actual_file);
926 cf = (s_list_t *) res->cached_files;
928 ml_foreach(cf, PRINTF(
"%s ", (
char *) ml_elem(__l)));
932 PRINTF(
"\nopenned files: ");
935 ofv = res->openned_files;
937 openned_file_t *of = (openned_file_t*)ofv;
938 PRINTF(
"%s ", of->fileFileName);
944void splitpath_local_suffix(
const char *url,
char **local_name,
char **suff);
948void fwl_resource_push_single_request(
const char *request)
950 resource_item_t *res;
955 res = resource_create_single(request);
957 resitem_enqueue(ml_new(res));
961 ttglobal tg = gglobal();
963 char* local_name = NULL;
964 splitpath_local_suffix(request, &local_name, &suff);
967 tg->Mainloop.scene_name = local_name;
968 tg->Mainloop.scene_suff = suff;
976void resource_push_multi_request(
struct Multi_String *request)
978 resource_item_t *res;
983 res = resource_create_multi(request);
984 resitem_enqueue(ml_new(res));
993void resource_tree_dump(
int level, resource_item_t *root)
995#define spacer for (lc=0; lc<level; lc++) printf ("\t");
1000 if (root == NULL)
return;
1001 if (level == 0) printf(
"\nResource tree:\n\n");
1004 spacer printf(
"==> request:\t %s\n\n", root->URLrequest);
1005 spacer printf(
"this:\t %p\n", root);
1006 spacer printf(
"parent:\t %p\n", root->parent);
1007 spacer printf(
"network:\t %s\n", BOOL_STR(root->network));
1008 spacer printf(
"new_root:\t %s\n", BOOL_STR(root->new_root));
1009 spacer printf(
"type:\t %u\n", root->type);
1010 spacer printf(
"status:\t %u\n", root->status);
1011 spacer printf(
"complete:\t %s\n", BOOL_STR(root->complete));
1012 spacer printf(
"where:\t %p\n", root->whereToPlaceData);
1013 spacer printf(
"offsetFromWhere:\t %d\n", root->offsetFromWhereToPlaceData);
1014 spacer printf(
"m_request:\t %p\n", root->m_request);
1015 spacer printf(
"base:\t %s\n", root->URLbase);
1016 spacer printf(
"temp_dir:\t %s\n", root->temp_dir);
1017 spacer printf(
"parsed_request:\t %s\n", root->parsed_request);
1018 spacer printf(
"actual_file:\t %s\n", root->actual_file);
1019 spacer printf(
"cached_files:\t %p\n", root->cached_files);
1025 spacer printf(
"four_first_bytes:\t %c %c %c %c\n", root->four_first_bytes[0], root->four_first_bytes[1], root->four_first_bytes[2], root->four_first_bytes[3]);
1026 spacer printf(
"media_type:\t %u\n", root->media_type);
1028 children = root->children;
1030 ml_foreach(children, resource_tree_dump(level + 1, ml_elem(__l)));
1035void resource_tree_count_files(
int *count, resource_item_t *root)
1037 if (root == NULL)
return;
1039 ml_foreach(root->children, resource_tree_count_files(count, ml_elem(__l)));
1041void printStatsResources()
1044 resource_tree_count_files(&count, gglobal()->resources.root_res);
1045 ConsoleMessage(
"%25s %d\n",
"resource file count", count);
1052void resource_tree_list_files(
int level, resource_item_t *root)
1054#define spacer for (lc=0; lc<level; lc++) printf ("\t");
1057 if (root == NULL)
return;
1058 if (level == 0) printf(
"\nResource file list:\n");
1060 spacer printf(
"%s\n", root->actual_file);
1061 ml_foreach(root->children, resource_tree_list_files(-1, ml_elem(__l)));
1064char *resourceTypeToString(
int type) {
1066 case rest_invalid:
return "rest_invalid";
1067 case rest_url:
return "rest_url";
1068 case rest_file:
return "rest_file";
1069 case rest_multi:
return "rest_multi";
1070 case rest_string :
return "rest_string ";
1071 default:
return "resource OUT OF RANGE";
1076char *resourceStatusToString(
int status) {
1078 case ress_none:
return "ress_none";
1079 case ress_starts_good:
return "ress_starts_good";
1080 case ress_invalid:
return "ress_invalid";
1081 case ress_downloaded:
return "ress_downloaded";
1082 case ress_failed:
return "ress_failed";
1083 case ress_loaded:
return "ress_loaded";
1084 case ress_not_loaded:
return "ress_not_loaded";
1085 case ress_parsed:
return "ress_parsed";
1086 case ress_not_parsed:
return "ress_not_parsed";
1087 default:
return "resource OUT OF RANGE";
1091char *resourceMediaTypeToString (
int mt) {
1093 case resm_unknown:
return " resm_unknown";
1094 case resm_vrml:
return " resm_vrml";
1095 case resm_x3d:
return " resm_x3d";
1096 case resm_image:
return " resm_image";
1097 case resm_image_buffer:
return " resm_image_buffer";
1098 case resm_movie:
return " resm_movie";
1099 case resm_pshader:
return " resm_pshader";
1100 case resm_fshader:
return " resm_fshader";
1101 case resm_mocap:
return " resm_mocap";
1102 case resm_x3z:
return " resm_x3z";
1103 case resm_gltf:
return " resm_gltf";
1104 case resm_glb:
return " resm_glb";
1105 case resm_bin:
return " resm_bin";
1106 case resm_b3dm:
return " resm_b3dm";
1107 case resm_i3dm:
return " resm_i3dm";
1108 case resm_pnts:
return " resm_pnts";
1109 case resm_cmpt:
return " resm_cmpt";
1110 case resm_midi:
return " resm_midi";
1111 default:
return "resource OUT OF RANGE";
1117#define SLASHDOTDOTSLASH "/../"
1118#if defined(_MSC_VER) || defined(_ANDROID) || defined(ANDROIDNDK)
1119#define rindex strrchr
1121void removeFilenameFromPath (
char *path) {
1123 char *slashDotDotSlash;
1126 slashindex = (
char *) rindex(path, ((
int)
'/'));
1127 if (slashindex != NULL) {
1130 }
else {path[0] = 0;}
1134 slashDotDotSlash = strstr(path, SLASHDOTDOTSLASH);
1135 while (slashDotDotSlash != NULL) {
1139 *slashDotDotSlash =
'\0';
1142 slashindex = (
char *)rindex(path, ((
int)
'/'));
1143 if (slashindex != NULL) {
1147 slashDotDotSlash += strlen(SLASHDOTDOTSLASH);
1148 strcpy(tmpline,path);
1150 strcat (tmpline, slashDotDotSlash);
1152 strcpy (path, tmpline);
1153 slashDotDotSlash = strstr(path, SLASHDOTDOTSLASH);
1163static void possiblyUnzip (openned_file_t *of) {
1164#if !(defined(IPHONE) || defined(_ANDROID))
1165 if (of->fileData == NULL)
return;
1166 if (of->fileData[0] ==
'\0')
return;
1167 if (of->fileData[1] ==
'\0')
return;
1168 if (((
unsigned char) of->fileData[0] == 0x1f) && ((
unsigned char) of->fileData[1] == 0x8b)) {
1169 #define GZIP_BUFF_SIZE 2048
1173 char buffer[GZIP_BUFF_SIZE];
1175 openned_file_t *newFile;
1181 tempname = TEMPNAM(gglobal()->Mainloop.tmpFileLocation,
"freewrl_tmp");
1184 source = gzopen(of->fileFileName,
"rb");
1185 dest = fopen(tempname,
"wb");
1187 if (!source || !source) {
1188 ConsoleMessage (
"unable to unzip this file: %s\n",of->fileFileName);
1189 printf (
"wow - problem\n");
1192 while ((num_read = gzread(source, buffer, GZIP_BUFF_SIZE)) > 0) {
1193 fwrite(buffer, 1, num_read, dest);
1200 newFile = load_file((
const char *) tempname);
1203 if (newFile->fileData == NULL) {
1204 ConsoleMessage (
"problem re-reading gunzipped text file");
1209 FREE_IF_NZ(of->fileData);
1210 of->fileData = newFile->fileData;
1213 FREE_IF_NZ(newFile);
1219bool resource_is_root_loaded()
1221 return ((gglobal()->resources.root_res != NULL) && (((resource_item_t*)gglobal()->resources.root_res)->status == ress_parsed));
1234void pushInputResource(resource_item_t *url)
1237 DEBUG_MSG(
"pushInputResource current Resource is %s", url->parsed_request);
1243 if (p->resStack==NULL) {
1244 p->resStack = newStack (resource_item_t *);
1255 stack_push (resource_item_t*, p->resStack, url);
1256 DEBUG_MSG(
"pushInputResource, after push, stack size %d",vectorSize(p->resStack));
1259void popInputResource() {
1260 resource_item_t *cwu;
1264 DEBUG_MSG(
"popInputResource, stack size %d",vectorSize(p->resStack));
1267 cwu = stack_top(resource_item_t *, p->resStack);
1270 stack_pop((resource_item_t *), p->resStack);
1272 if (stack_empty(p->resStack)) {
1273 DEBUG_MSG (
"popInputResource, stack now empty and we have saved the last resource\n");
1274 p->lastBaseResource = cwu;
1276 cwu = stack_top(resource_item_t *, p->resStack);
1277 DEBUG_MSG(
"popInputResource, cwu = %p",cwu);
1278 DEBUG_MSG(
"popInputResource before pop, current Resource is %s\n", cwu->parsed_request);
1282resource_item_t *getInputResource()
1284 resource_item_t *cwu;
1288 DEBUG_MSG(
"getInputResource \n");
1289 if (p->resStack==NULL) {
1290 DEBUG_MSG(
"getInputResource, stack NULL\n");
1295 if (stack_empty(p->resStack)) {
1296 if (p->lastBaseResource == NULL) {
1297 ConsoleMessage (
"stacking error - looking for input resource, but it is null");
1299 DEBUG_MSG(
"so, returning %s\n",p->lastBaseResource->parsed_request);
1302 return p->lastBaseResource;
1306 cwu = stack_top(resource_item_t *, p->resStack);
1307 DEBUG_MSG(
"getInputResource current Resource is %lu %lx %s\n", (
unsigned long int) cwu, (
unsigned long int) cwu, cwu->parsed_request);
1313char* fwl_resitem_getURL(
void *resp){
1314 resource_item_t *res = (resource_item_t *)resp;
1315 return res->parsed_request;
1317void fwl_resitem_setActualFile(
void *resp,
char *fname){
1318 resource_item_t *res = (resource_item_t *)resp;
1319 res->actual_file = STRDUP(fname);
1320 if(strcmp(res->actual_file,res->parsed_request)){
1323 item = ml_new(res->actual_file);
1324 if (!res->cached_files)
1325 res->cached_files = (
void *)item;
1327 res->cached_files = ml_append(res->cached_files,item);
1330char* fwl_resitem_getTempDir(
void *resp){
1331 resource_item_t *res = (resource_item_t *)resp;
1332 return res->temp_dir;
1334void fwl_resitem_enqueuNextMulti(
void *resp){
1335 resource_item_t *res = (resource_item_t *)resp;
1336 int more_multi = (res->status == ress_failed) && (res->m_request != NULL);
1339 res->status = ress_invalid;
1340 res->type = rest_multi;
1343 resource_identify(res->parent, res);
1344 frontenditem_enqueue(ml_new(res));
1347char *strBackslash2fore(
char *);
1349void fwl_resitem_setLocalPath(
void *resp,
char* path){
1350 int delete_after_load;
1351 resource_item_t *res = (resource_item_t *)resp;
1352 res->status = ress_downloaded;
1353 res->actual_file = strBackslash2fore(STRDUP(path));
1354 delete_after_load = 1;
1355 if (delete_after_load){
1359 item = ml_new(res->actual_file);
1360 if (!res->cached_files)
1361 res->cached_files = (
void *)item;
1363 res->cached_files = ml_append(res->cached_files, item);
1365 res->_loadFunc = (
void *)file2blob;
1367int fwl_resitem_getStatus(
void *resp){
1368 resource_item_t *res = (resource_item_t *)resp;
1371void fwl_resitem_setStatus(
void *resp,
int status) {
1372 resource_item_t *res = (resource_item_t *)resp;
1373 res->status = status;
1376int fwl_resitem_getType(
void *resp){
1377 resource_item_t *res = (resource_item_t *)resp;
1380int fwl_resitem_getMediaType(
void *resp){
1381 resource_item_t *res = (resource_item_t *)resp;
1382 return res->media_type;
1384void fwl_resitem_setDownloadThread(
void *resp,
void *thread){
1385 resource_item_t *res = (resource_item_t *)resp;
1386 res->_loadThread = (pthread_t*)thread;
1388void * fwl_resitem_getDownloadThread(
void *resp){
1389 resource_item_t *res = (resource_item_t *)resp;
1390 return res->_loadThread;
1392void * fwl_resitem_getGlobal(
void *resp){
1393 resource_item_t *res = (resource_item_t *)resp;