static BOOL is_filter_file(u16 *p_filter, u16 *p_name)
{
u16 *p_ch = NULL;
u16 *p_tip = NULL;
u16 filter[MAX_FILE_PATH] = {0};
uni_strncpy(filter, p_filter, MAX_FILE_PATH);
p_tip = uni_strrchr(p_name, 0x2e/*'.'*/);
if (p_tip == NULL)
{
return FALSE;
}
while (1)
{
p_ch = uni_strrchr(filter, 0x7c/*'|'*/);
if (p_ch == NULL)
{
return FALSE;
}
p_ch[0] = 0x2e/*'.'*/;
if (uni_strcmp(p_ch, p_tip) == 0)
{
return TRUE;
}
p_ch[0] = 0/*'\0'*/;
}
//return FALSE;
}
/*!
* is enter directory
*/
BOOL ui_video_file_is_enter_dir(void)
{
u16 *p_temp = NULL;
u16 parent[4] = {0};
u16 curn[4] = {0};
u16 cur_path[255] = {0};
if(g_video_m.flist_dir != NULL && g_video_m.file_list.file_count != 0)
{
uni_strcpy(cur_path, g_video_m.file_list.p_file[0].name);
p_temp = uni_strrchr(cur_path, 0x5c/*'\\'*/);
if (p_temp != NULL)
{
//parent dir
str_asc2uni("..", parent);
str_asc2uni(".", curn);
if (uni_strlen(p_temp) >= 3 && uni_strcmp(p_temp + 1, parent/*".."*/) == 0)
{
p_temp[0] = 0/*'\0'*/;
p_temp = uni_strrchr(cur_path, 0x5c/*'\\'*/);
if (p_temp != NULL)
{
p_temp[0] = 0/*'\0'*/;
}
}
//cur dir
else if (uni_strlen(p_temp) >= 2 && uni_strcmp(p_temp + 1, curn/*"."*/) == 0)
{
p_temp[0] = 0/*'\0'*/;
}
else
{
return FALSE;
}
}
else
{
return FALSE;
}
}
else
{
return FALSE;
}
return TRUE;
}
static BOOL is_filter_nodir(u16 *p_filter)
{
u16 *p_ch = NULL;
u16 tip[8] = {0};
u16 filter[MAX_FILE_PATH] = {0};
u16 nodir[8] = {0};
uni_strncpy(filter, p_filter, MAX_FILE_PATH);
str_asc2uni(".nodir", nodir);
uni_strcpy(tip, nodir);
while (1)
{
p_ch = uni_strrchr(filter, 0x7c/*'|'*/);
if (p_ch == NULL)
{
return FALSE;
}
p_ch[0] = 0x2e/*'.'*/;
if (uni_strcmp(p_ch, tip) == 0)
{
return TRUE;
}
p_ch[0] = 0/*'\0'*/;
}
//return FALSE;
}
int OpStringC16::FindLastOf(uni_char aChar) const
{
if (iBuffer==NULL)
return KNotFound;
const uni_char *s = uni_strrchr(iBuffer,aChar);
if (s==NULL)
return KNotFound;
return s-iBuffer;
}
void * flist_add_fav_by_name(u16 *p_name, void **pp_media_fav, media_fav_type_t type)
{
media_fav_t *p_fav_next = *(media_fav_t **)pp_media_fav;
u32 next_len = 0;
u16 *p_tip = NULL;
CHECK_FAIL_RET_NULL(p_name != NULL);
if (type == RECORD_FAV)
{
next_len = sizeof(rec_fav_t);
}
else
{
next_len = sizeof(media_fav_t);
}
while (p_fav_next)
{
if (!uni_strcmp(p_name, p_fav_next->path))
{
OS_PRINTF("\n##debug: flist_add_fav_by_name [%s] exist!!\n", p_name);
return p_fav_next;
}
if (p_fav_next->p_next == NULL)
{
break;
}
p_fav_next = p_fav_next->p_next;
}
if (p_fav_next)
{
p_fav_next->p_next = mtos_malloc(next_len);
CHECK_FAIL_RET_NULL(p_fav_next->p_next != NULL);
p_fav_next = p_fav_next->p_next;
}
else
{
p_fav_next = mtos_malloc(next_len);
CHECK_FAIL_RET_NULL(p_fav_next != NULL);
*pp_media_fav = p_fav_next;
}
p_fav_next->p_next = NULL;
memset(p_fav_next, 0, next_len);
uni_strcpy(p_fav_next->path, p_name);
if(type != RECORD_FAV)
{
p_tip = uni_strrchr(p_fav_next->path, 0x5c/*'\'*/);
p_fav_next->p_filename = ++ p_tip;
}
return p_fav_next;
}
static void check_dir_order(media_file_t *p_file, u32 file_cnt)
{
s32 loopi = 0;
u32 ex_index = 0;
media_file_t file;
memset(&file, 0, sizeof(media_file_t));
if (p_file[file_cnt -2].type == DIRECTORY)
{
return ;
}
for (loopi = file_cnt - 2; loopi >= 0; loopi --)
{
if (p_file[loopi].type == DIRECTORY)
{
ex_index = loopi + 1;
break;
}
}
if (loopi == -1)
{
ex_index = 0;
}
memcpy(&file, &(p_file[file_cnt - 1]), sizeof(media_file_t));
memcpy(&(p_file[file_cnt - 1]), &(p_file[ex_index]), sizeof(media_file_t));
memcpy(&(p_file[ex_index]), &file, sizeof(media_file_t));
p_file[file_cnt - 1].p_name = uni_strrchr(p_file[file_cnt - 1].name, 0x5c/*'\\'*/) + 1;
p_file[file_cnt - 1].default_order = file_cnt - 1;
p_file[ex_index].p_name = uni_strrchr(p_file[ex_index].name, 0x5c/*'\\'*/) + 1;
p_file[ex_index].default_order = ex_index;
}
static u32 get_new_file(file_list_dir_t *p_flist_dir, media_file_t *p_file)
{
RET_CODE ret = 0;
vfs_dir_info_t file_info;
u32 file_cnt = 0;
u32 fname_len = 0, fpath_len = 0;
u16 uni_str[8] = {0};
file_cnt = 0;
while (file_cnt < p_flist_dir->unit_cnt)
{
ret = vfs_readdir (p_flist_dir->cur_dir, &file_info);
if (ret != SUCCESS)
//|| file_info.fname[0] == 0)
{
OS_PRINTF("\n##debug: ufs_readdir end!\n");
break;
}
fpath_len = uni_strlen(p_flist_dir->cur_path);
fname_len = uni_strlen(file_info.fname);
if(fpath_len + fname_len + 1 < MAX_FILE_PATH)
{
memset(p_file[file_cnt].name, 0, MAX_FILE_PATH * sizeof(u16));
uni_strcpy(p_file[file_cnt].name, p_flist_dir->cur_path);
if (p_file[file_cnt].name[uni_strlen(p_file[file_cnt].name) - 1] != 0x5c/*'\\'*/)
{
uni_str[0] = 0x5c;
uni_str[1] = 0;
uni_strcat(p_file[file_cnt].name, uni_str, MAX_FILE_PATH);
}
if ((file_info.fattrib & VFS_DIR) && !is_filter_nodir(p_flist_dir->filter))
{
uni_str[0] = 0x2e;
uni_str[1] = 0;
if (uni_strcmp(file_info.fname, uni_str))
{
uni_strcat(p_file[file_cnt].name, file_info.fname, MAX_FILE_PATH);
p_file[file_cnt].p_name = uni_strrchr(p_file[file_cnt].name, 0x5c/*'\\'*/) + 1;
p_file[file_cnt].type = DIRECTORY;
p_file[file_cnt].size = file_info.fsize;
p_file[file_cnt].default_order = file_cnt;
file_cnt ++;
if (file_cnt >= 2)
{
check_dir_order(p_file, file_cnt);
}
}
}
else if (p_flist_dir->filter[0] == 0/*'\0'*/
|| is_filter_file(p_flist_dir->filter, file_info.fname))
{
uni_strcat(p_file[file_cnt].name, file_info.fname, MAX_FILE_PATH);
p_file[file_cnt].p_name = uni_strrchr(p_file[file_cnt].name, 0x5c/*'\\'*/) + 1;
p_file[file_cnt].type = NOT_DIR_FILE;
p_file[file_cnt].size = file_info.fsize;
p_file[file_cnt].default_order = file_cnt;
file_cnt ++;
}
}
}
/*for(c**t = 0; c**t < (file_cnt + 1); c**t ++)
{
p_file[c**t].default_order = c**t;
}*/
return file_cnt;
}
u32 flist_load_fav(u16 partition_letter, void **pp_media_fav, media_fav_type_t type)
{
u16 file_name[MAX_FILE_PATH] = {0};
hfile_t file = NULL;
vfs_file_info_t file_info = {0};
u32 read_size = 0;
u32 fav_cnt = 0;
media_fav_t *p_media_fav = NULL;
media_fav_t *p_prev = NULL;
media_fav_header_t head = {0};
u32 media_fav_len = 0;
u16 *p_tip = NULL;
u8 *p_buffer = NULL;
u8 *p_r_buf = NULL;
file_name[0] = partition_letter;
switch(type)
{
case AUDIO_FAV:
str_asc2uni(":\\audio_fav_list", file_name + 1);
media_fav_len = sizeof(media_fav_t);
break;
case PIC_FAV:
str_asc2uni(":\\pic_fav_list", file_name + 1);
media_fav_len = sizeof(media_fav_t);
break;
case RECORD_FAV:
str_asc2uni(":\\PVRS\\mt_record_list", file_name + 1);
media_fav_len = sizeof(rec_fav_t);
break;
default:
return 0;
}
file = vfs_open(file_name, VFS_READ);
if(file == NULL)
{
return 0;
}
vfs_get_file_info(file, &file_info);
if(!file_info.file_size)
{
vfs_close(file);
return 0;
}
p_buffer = mtos_align_malloc(file_info.file_size + 4, 16);
if (p_buffer != NULL)
{
memset(p_buffer, 0, file_info.file_size + 4);
read_size = vfs_read(p_buffer, file_info.file_size, 1, file);
if (read_size != file_info.file_size)
{
mtos_align_free(p_buffer);
vfs_close(file);
return 0;
}
read_size = 0;
p_r_buf = p_buffer;
while (read_size < file_info.file_size)
{
memcpy((u8 *)(&head), p_r_buf, sizeof(media_fav_header_t));
p_r_buf += sizeof(media_fav_header_t);
read_size += sizeof(media_fav_header_t);
if ((read_size >= file_info.file_size)
|| !head.payload)
{
break;
}
if (head.payload >= media_fav_len)
{
break;
}
p_media_fav = mtos_malloc(media_fav_len);
CHECK_FAIL_RET_ZERO(p_media_fav != NULL);
memcpy((u8 *)((u32)p_media_fav + 4), p_r_buf, head.payload);
read_size += head.payload;
p_r_buf += head.payload;
p_media_fav->path[0] = partition_letter;
if((type != RECORD_FAV))
{
p_tip = uni_strrchr(p_media_fav->path, 0x5c/*'\\'*/);
p_media_fav->p_filename = ++ p_tip;
}
p_media_fav->p_next = NULL;
if (fav_cnt == 0)
{
*pp_media_fav = p_media_fav;
}
else
{
p_prev->p_next = p_media_fav;
}
fav_cnt ++;
p_prev = p_media_fav;
}
mtos_align_free(p_buffer);
vfs_close(file);
return fav_cnt;
}
while (1)
{
read_size = vfs_read((u8 *)(&head), sizeof(media_fav_header_t), 1, file);
if (read_size != sizeof(media_fav_header_t)
|| !head.payload)
{
break;
}
if (head.payload >= media_fav_len)
{
break;
}
p_media_fav = mtos_malloc(media_fav_len);
CHECK_FAIL_RET_ZERO(p_media_fav != NULL);
read_size = vfs_read((u8 *)p_media_fav + 4, head.payload, 1, file);
p_media_fav->path[0] = partition_letter;
if((type != RECORD_FAV))
{
p_tip = uni_strrchr(p_media_fav->path, 0x5c/*'\\'*/);
p_media_fav->p_filename = ++ p_tip;
}
if (read_size != (media_fav_len - 4))
{
break;
}
p_media_fav->p_next = NULL;
if (fav_cnt == 0)
{
*pp_media_fav = p_media_fav;
}
else
{
p_prev->p_next = p_media_fav;
}
fav_cnt ++;
p_prev = p_media_fav;
}
vfs_close(file);
return fav_cnt;
}
flist_dir_t flist_open_dir(u16 *p_filter, u16 *p_path, u32 *p_total_cnt)
{
file_list_priv_t *p_priv = NULL;
flist_dir_priv_t *p_dir_priv = NULL;
u16 *p_temp = NULL;
u16 parent[4] = {0};
u16 curn[4] = {0};
CHECK_FAIL_RET_NULL(p_path != NULL);
p_priv = class_get_handle_by_id(FILE_LIST_CLASS_ID);
if (p_priv->p_opened_dir)
{
OS_PRINTF("\n\n\n##waring:please close/leave dir[0x%x] first!\n", p_priv->p_opened_dir);
}
p_dir_priv = mtos_malloc(sizeof(flist_dir_priv_t));
CHECK_FAIL_RET_NULL(p_dir_priv != NULL);
memset(p_dir_priv, 0, sizeof(flist_dir_priv_t));
p_dir_priv->p_flist = NULL;
p_dir_priv->start_idx = 0;
p_dir_priv->total_cnt = 0;
uni_strcpy(p_dir_priv->cur_path, p_path);
if (p_filter != NULL)
{
uni_strncpy(p_dir_priv->filter, p_filter, MAX_FILE_PATH);
}
p_temp = uni_strrchr(p_dir_priv->cur_path, 0x5c/*'\\'*/);
if (p_temp != NULL)
{
//parent dir
str_asc2uni("..", parent);
str_asc2uni(".", curn);
if (uni_strlen(p_temp) >= 3 && uni_strcmp(p_temp + 1, parent/*".."*/) == 0)
{
p_temp[0] = 0/*'\0'*/;
p_temp = uni_strrchr(p_dir_priv->cur_path, 0x5c/*'\\'*/);
if (p_temp != NULL)
{
p_temp[0] = 0/*'\0'*/;
}
}
//cur dir
else if (uni_strlen(p_temp) >= 2 && uni_strcmp(p_temp + 1, curn/*"."*/) == 0)
{
p_temp[0] = 0/*'\0'*/;
}
}
p_dir_priv->vfs_dir = vfs_opendir (p_dir_priv->cur_path, p_priv->max_support_cnt);
if (p_dir_priv->vfs_dir == NULL)
{
mtos_free(p_dir_priv);
p_dir_priv = NULL;
return NULL;
}
OS_PRINTF("\n##flist read dir please wait...\n");
flist_reload_dir(p_dir_priv);
if (p_total_cnt)
{
*p_total_cnt = p_dir_priv->total_cnt;
}
p_priv->p_opened_dir = p_dir_priv;
return (flist_dir_t)p_dir_priv;
}
static u32 flist_read_dir_one(flist_dir_priv_t *p_flist_dir, media_file_t *p_file)
{
RET_CODE ret = 0;
vfs_dir_info_t file_info;
u32 file_cnt = 0;
u32 fname_len = 0, fpath_len = 0;
u16 uni_str[8] = {0};
while (file_cnt < 1)
{
ret = vfs_readdir (p_flist_dir->vfs_dir, &file_info);
if (ret != SUCCESS)
{
OS_PRINTF("\n##debug: ufs_readdir end!\n");
break;
}
fpath_len = uni_strlen(p_flist_dir->cur_path);
fname_len = uni_strlen(file_info.fname);
if (fpath_len + fname_len + 1 < MAX_FILE_PATH)
{
if (p_file)
{
memset(p_file->name, 0, MAX_FILE_PATH * sizeof(u16));
uni_strcpy(p_file->name, p_flist_dir->cur_path);
if (p_file->name[uni_strlen(p_file->name) - 1] != 0x5c/*'\\'*/)
{
uni_str[0] = 0x5c;
uni_str[1] = 0;
uni_strcat(p_file->name, uni_str, MAX_FILE_PATH);
}
}
if ((file_info.fattrib & VFS_DIR) && !is_filter_nodir(p_flist_dir->filter))
{
uni_str[0] = 0x2e;
uni_str[1] = 0;
if (uni_strcmp(file_info.fname, uni_str))
{
if (p_file)
{
uni_strcat(p_file->name, file_info.fname, MAX_FILE_PATH);
p_file->p_name = uni_strrchr(p_file->name, 0x5c/*'\\'*/) + 1;
p_file->type = DIRECTORY;
p_file->size = file_info.fsize;
}
file_cnt ++;
break;
}
}
else if ((p_flist_dir->filter[0] == 0 || is_filter_file(p_flist_dir->filter, file_info.fname)))
{
if (p_file)
{
uni_strcat(p_file->name, file_info.fname, MAX_FILE_PATH);
p_file->p_name = uni_strrchr(p_file->name, 0x5c/*'\\'*/) + 1;
p_file->type = NOT_DIR_FILE;
p_file->size = file_info.fsize;
}
file_cnt ++;
break;
}
}
}
return file_cnt;
}
flist_dir_t file_list_enter_dir(u16 *p_filter, u16 unit_cnt, u16 *p_path)
{
file_list_priv_t *p_priv = NULL;
file_list_dir_t *p_flist_dir = NULL;
u16 *p_temp = NULL;
u16 parent[4] = {0};
u16 curn[4] = {0};
CHECK_FAIL_RET_NULL(p_path != NULL);
if (unit_cnt == 0)
{
return NULL;
}
p_priv = class_get_handle_by_id(FILE_LIST_CLASS_ID);
if (p_priv->p_opened_dir)
{
OS_PRINTF("\n\n\n##waring:please close/leave dir[0x%x] first!\n", p_priv->p_opened_dir);
}
p_flist_dir = mtos_malloc(sizeof(file_list_dir_t));
CHECK_FAIL_RET_NULL(p_flist_dir != NULL);
memset(p_flist_dir, 0, sizeof(file_list_dir_t));
uni_strcpy(p_flist_dir->cur_path, p_path);
if (p_filter != NULL)
{
uni_strncpy(p_flist_dir->filter, p_filter, MAX_FILE_PATH);
}
p_flist_dir->unit_cnt = unit_cnt;
p_temp = uni_strrchr(p_flist_dir->cur_path, 0x5c/*'\\'*/);
if (p_temp != NULL)
{
//parent dir
str_asc2uni("..", parent);
str_asc2uni(".", curn);
if (uni_strlen(p_temp) >= 3 && uni_strcmp(p_temp + 1, parent/*".."*/) == 0)
{
p_temp[0] = 0/*'\0'*/;
p_temp = uni_strrchr(p_flist_dir->cur_path, 0x5c/*'\\'*/);
if (p_temp != NULL)
{
p_temp[0] = 0/*'\0'*/;
}
}
//cur dir
else if (uni_strlen(p_temp) >= 2 && uni_strcmp(p_temp + 1, curn/*"."*/) == 0)
{
p_temp[0] = 0/*'\0'*/;
}
}
p_flist_dir->cur_dir = vfs_opendir (p_flist_dir->cur_path, unit_cnt);
if (p_flist_dir->cur_dir == NULL)
{
mtos_free(p_flist_dir);
p_flist_dir = NULL;
}
p_priv->p_opened_dir = p_flist_dir;
return (flist_dir_t)p_flist_dir;
}
u16 ui_video_m_get_video_icon(u16 *p_filename)
{
u16 id = IM_M_ICON_AVI;
u16 *p_tip = NULL;
u8 *p_ext = NULL;
if(NULL == p_filename)
{
return id;
}
p_tip = uni_strrchr(p_filename, char_asc2uni('.'));
if(NULL == p_tip)
{
return id;
}
p_ext = (u8 *)mtos_malloc(uni_strlen(p_tip) + 1);
str_uni2asc(p_ext, p_tip);
if(STRCMPI(p_ext, ".AVI") == 0)
{
id = IM_M_ICON_AVI;
}
else if(STRCMPI(p_ext, ".MKV") == 0)
{
id = IM_M_ICON_MKV;
}
else if(STRCMPI(p_ext, ".MP4") == 0)
{
id = IM_M_ICON_MP4;
}
else if(STRCMPI(p_ext, ".M2TS") == 0)
{
id = IM_M_ICON_M2TS;
}
else if(STRCMPI(p_ext, ".F4V") == 0)
{
id = IM_M_ICON_F4V;
}
else if(STRCMPI(p_ext, ".3GP") == 0)
{
id = IM_M_ICON_3GP;
}
else if(STRCMPI(p_ext, ".MOV") == 0)
{
id = IM_M_ICON_MOV;
}
else if(STRCMPI(p_ext, ".FLV") == 0)
{
id = IM_M_ICON_FLV;
}
else if(STRCMPI(p_ext, ".TS") == 0)
{
id = IM_M_ICON_TS;
}
else if(STRCMPI(p_ext, ".MPG") == 0)
{
id = IM_M_ICON_MPG;
}
mtos_free(p_ext);
return id;
}
OP_STATUS OpFolderListing::GenerateData()
{
#ifdef _LOCALHOST_SUPPORT_
// Prefix for local files
# ifdef HAS_COMPLEX_GLOBALS
static const uni_char * const localhost_prefix =
UNI_L("file://localhost/");
# else
# define localhost_prefix UNI_L("file://localhost/")
# endif
static const size_t localhost_prefix_len = 17;
OP_ASSERT(uni_strlen(localhost_prefix) == localhost_prefix_len);
#endif
const uni_char * OP_MEMORY_VAR dirend_char = UNI_L("");
#if PATHSEPCHAR != '/'
const uni_char * OP_MEMORY_VAR displayable_dirend_char = dirend_char;
#else
# define displayable_dirend_char dirend_char
#endif
// FIXME: OOM - not reported, not checked
// Set attributes.
m_url.SetAttribute(URL::KIsDirectoryListing, TRUE);
// Get the URL and take copies of it for processing.
OpString base;
RETURN_IF_ERROR(m_url.GetAttribute(URL::KUniName_Username_Escaped, base));
m_temp_base = SetNewStr(base.CStr());
m_displayable_base_url = SetNewStr(base.CStr());
if (!m_temp_base || !m_displayable_base_url)
{
return OpStatus::ERR_NO_MEMORY;
}
// Check if this is a local file or not.
#ifdef _LOCALHOST_SUPPORT_
OP_MEMORY_VAR bool is_local_file = false;
#else
static const bool is_local_file = false;
#endif
#ifdef _LOCALHOST_SUPPORT_
if (uni_strncmp(m_displayable_base_url, localhost_prefix, localhost_prefix_len) == 0)
{
is_local_file = true;
}
#endif
static const uni_char pathsepchar = '/';
// If wildchars, remove upto last PATHSEPCHAR/
unsigned int PathLen = uni_strcspn(m_temp_base, UNI_L(WILDCHARS));
if (PathLen != uni_strlen(m_temp_base))
{
int i;
for (i = PathLen; i > 0 && m_temp_base[i] != PATHSEPCHAR && m_temp_base[i] != '/' && m_temp_base[i] != '\\' ; i--) {}
m_temp_base[i] = '\0';
}
PathLen = uni_strcspn(m_temp_base,UNI_L("?"));
m_temp_base[PathLen] = '\0';
{
// Ignore parameter portion, but only for the last element to ensure
// proper path names for FTP and file (anyone using parameters in the
// parent directories will just have to take their chances).
uni_char *temp_path = uni_strrchr(m_temp_base, '/'); // don't bother looking for backslash
if(temp_path)
{
uni_char *temp_param = uni_strchr(temp_path, ';');
if(temp_param)
{
PathLen = temp_param - m_temp_base;
m_temp_base[PathLen] = '\0';
}
}
}
// If the path does not end in a path separator, add one.
if (m_temp_base[PathLen-1] != '/'
#if PATHSEPCHAR != '/'
&& m_temp_base[PathLen-1] != PATHSEPCHAR
#endif
)
{
dirend_char = UNI_L("/");
#if PATHSEPCHAR != '/'
if (is_local_file)
{
displayable_dirend_char = UNI_L(PATHSEP);
}
else
{
displayable_dirend_char = dirend_char;
}
#endif
}
// Create a HTML version of the URL string.
m_htmlified_url = HTMLify_string(m_temp_base);
if (!m_htmlified_url)
{
return OpStatus::ERR_NO_MEMORY;
}
// Transmogrify the URL to make it displayable.
UriUnescape::ReplaceChars(m_displayable_base_url,
(static_cast<URLType>(m_url.GetAttribute(URL::KType)) == URL_FILE ?
UriUnescape::LocalfileUrlUtf8 : UriUnescape::SafeUtf8));
// Remove localhost prefix
if (is_local_file)
op_memmove(m_displayable_base_url, m_displayable_base_url + localhost_prefix_len, UNICODE_SIZE(uni_strlen(m_displayable_base_url + localhost_prefix_len) + 1));
#ifdef SYS_CAP_FILESYSTEM_HAS_DRIVES
// Clean up the generated path string
if (is_local_file)
{
// Replace Netscape-compatible "|" as drive letter postfix with
// a drive separator, which we assume to be ":"
if (m_displayable_base_url[0] &&
'|' == m_displayable_base_url[1])
{
m_displayable_base_url[1] = ':';
}
// Make sure drive letter is upper-cased
if (Unicode::IsLower(m_displayable_base_url[0]))
{
m_displayable_base_url[0] = Unicode::ToUpper(m_displayable_base_url[0]);
}
}
#endif
// Remove formatting characters
RemoveFormattingCharacters(m_displayable_base_url);
// Create a HTML version of the displayable URL string.
m_htmlified_displayable_base_url = HTMLify_string(m_displayable_base_url);
if (!m_htmlified_displayable_base_url)
{
return OpStatus::ERR_NO_MEMORY;
}
// Set up the document title from the displayable URL string.
OpString document_title;
#ifndef SYS_CAP_FILESYSTEM_HAS_DRIVES
if (is_local_file)
{
// Include an initial slash for local files on file systems that do
// not have drive letters, to avoid blank titles or titles like
// "usr/bin".
if (uni_strcmp(m_htmlified_displayable_base_url, localhost_prefix) == 0)
{
RETURN_IF_ERROR(document_title.Set("/"));
}
else
{
RETURN_IF_ERROR(document_title.SetConcat(UNI_L("/"), m_htmlified_displayable_base_url));
}
}
else
#endif
{
RETURN_IF_ERROR(document_title.Set(m_htmlified_displayable_base_url));
}
// Write the document.
#ifdef _LOCALHOST_SUPPORT_
OpString dirstyle;
TRAP_AND_RETURN(rc, g_pcfiles->GetFileURLL(PrefsCollectionFiles::StyleDirFile, &dirstyle));
RETURN_IF_ERROR(OpenDocument(document_title.CStr(), dirstyle.CStr()));
#else
RETURN_IF_ERROR(OpenDocument(document_title.CStr(), NULL));
#endif
m_url.WriteDocumentDataUniSprintf(UNI_L(" <base href=\"%s%s\">\n"), m_htmlified_url, dirend_char);
RETURN_IF_ERROR(OpenBody(Str::S_FOLDER_LISTING_TEXT));
RETURN_IF_ERROR(m_url.WriteDocumentData(URL::KNormal, UNI_L("<h2>")));
// Provide links to each parent directory in the hierarchy.
size_t len_htmlified = uni_strlen(m_htmlified_url);
size_t len_displayable = uni_strlen(m_htmlified_displayable_base_url);
size_t idx_htmlified = 0, idx_displayable = 0;
uni_char *protocolsuffix = NULL;
if (NULL != (protocolsuffix = uni_strstr(m_htmlified_url, UNI_L("://"))))
{
uni_char *thirdslash = uni_strchr(protocolsuffix + 3, '/');
if (thirdslash)
{
idx_htmlified = thirdslash - m_htmlified_url + 1;
if(!is_local_file)
{
m_url.WriteDocumentDataUniSprintf(UNI_L("<a href=\"%.*s\">%.*s</a>"), idx_htmlified, m_htmlified_url, idx_htmlified, m_htmlified_url);
}
}
else
{
idx_htmlified = static_cast<size_t>(-1);
}
}
else
{
idx_htmlified = static_cast<size_t>(-1);
}
if (NULL != (protocolsuffix = uni_strstr(m_htmlified_displayable_base_url, UNI_L("://"))))
{
uni_char *thirdslash = uni_strchr(protocolsuffix + 3, '/');
if (thirdslash)
{
idx_displayable = thirdslash - m_htmlified_displayable_base_url + 1;
}
}
if (static_cast<size_t>(-1) == idx_htmlified)
{
m_url.WriteDocumentDataUniSprintf(UNI_L("%s%s</h2>\n\n"),
m_htmlified_url, displayable_dirend_char);
}
else
{
#ifndef SYS_CAP_FILESYSTEM_HAS_DRIVES
if (is_local_file)
{
// Add the initial slash manually, as it does not have a
// left-hand-side component.
m_url.WriteDocumentDataUniSprintf(UNI_L("<a href=\"%s\">/</a>"), localhost_prefix);
}
#endif
while (idx_htmlified < len_htmlified && idx_displayable < len_displayable)
{
uni_char *nextslash_htmlified = uni_strchr(m_htmlified_url + idx_htmlified, '/');
if (!nextslash_htmlified)
{
nextslash_htmlified = m_htmlified_url + len_htmlified;
}
uni_char *nextslash_displayable =
uni_strchr(m_htmlified_displayable_base_url + idx_displayable, pathsepchar);
if (!nextslash_displayable)
{
nextslash_displayable = m_htmlified_displayable_base_url + len_displayable;
}
int temp_idx_htmlified = nextslash_htmlified - m_htmlified_url;
int temp_idx_displayable = nextslash_displayable - m_htmlified_displayable_base_url;
m_url.WriteDocumentDataUniSprintf(UNI_L("<a href=\"%.*s/\">%.*s</a>/"),
temp_idx_htmlified, m_htmlified_url,
temp_idx_displayable - idx_displayable, &m_htmlified_displayable_base_url[idx_displayable]);
idx_htmlified = temp_idx_htmlified + 1;
idx_displayable = temp_idx_displayable + 1;
}
m_url.WriteDocumentData(URL::KNormal, UNI_L("</h2>\n\n"));
}
// Clean up.
delete[] m_temp_base; m_temp_base = NULL;
delete[] m_htmlified_url; m_htmlified_url = NULL;
delete[] m_displayable_base_url; m_displayable_base_url = NULL;
delete[] m_htmlified_displayable_base_url; m_htmlified_displayable_base_url = NULL;
return OpStatus::OK;
}
