static int _mapMaker(struct tree_node_t *node, void *cargo)
{
uidToTitleMap_t *uidToTitleMapPtr = (uidToTitleMap_t *)cargo;
struct guide_nodedata_t *data =
(struct guide_nodedata_t *)tree_get_data(node);
uint32 existingUID = 0;
if (uidToTitleMapPtr->Lookup(data->title, existingUID) == FALSE)
uidToTitleMapPtr->SetAt(data->title, data->uid);
return 0;
}
int
check_directory_for_color_scheme(int left, const char dir[])
{
char *p;
char t;
int altered;
union
{
char *name;
tree_val_t buf;
}
u;
if(dirs == NULL_TREE)
{
return 0;
}
curr_stats.cs = left ? &lwin.cs : &rwin.cs;
assign_color_scheme(curr_stats.cs, &cfg.cs);
/* TODO: maybe use split_and_get() here as in io/iop:iop_mkdir(). */
p = (char *)dir;
altered = 0;
do
{
t = *p;
*p = '\0';
if(tree_get_data(dirs, dir, &u.buf) == 0 && color_scheme_exists(u.name))
{
(void)source_cs(u.name);
altered = 1;
}
*p = t;
p = until_first(p + 1, '/');
}
while(t != '\0');
curr_stats.cs = &cfg.cs;
if(!altered)
{
return 0;
}
check_color_scheme(curr_stats.cs);
load_color_pairs(curr_stats.cs);
return 1;
}
/* The return value is the color scheme base number for the colorpairs.
*
* The color scheme with the longest matching directory path is the one that
* should be returned.
*/
int
check_directory_for_color_scheme(int left, const char *dir)
{
char *p;
char t;
union
{
char *name;
tree_val_t buf;
}u;
if(dirs == NULL_TREE)
{
return DCOLOR_BASE;
}
curr_stats.cs_base = left ? LCOLOR_BASE : RCOLOR_BASE;
curr_stats.cs = left ? &lwin.cs : &rwin.cs;
*curr_stats.cs = cfg.cs;
p = (char *)dir;
do
{
char full[PATH_MAX];
t = *p;
*p = '\0';
if(tree_get_data(dirs, dir, &u.buf) != 0 || !color_scheme_exists(u.name))
{
*p = t;
if((p = strchr(p + 1, '/')) == NULL)
p = (char *)dir + strlen(dir);
continue;
}
snprintf(full, sizeof(full), "%s/colors/%s", cfg.config_dir, u.name);
(void)source_file(full);
*p = t;
if((p = strchr(p + 1, '/')) == NULL)
p = (char *)dir + strlen(dir);
}
while(t != '\0');
check_color_scheme(curr_stats.cs);
load_color_pairs(curr_stats.cs_base, curr_stats.cs);
curr_stats.cs_base = DCOLOR_BASE;
curr_stats.cs = &cfg.cs;
return left ? LCOLOR_BASE : RCOLOR_BASE;
}
static int _linkFixer(struct tree_node_t *node, void *cargo)
{
uidToTitleMap_t *uidToTitleMapPtr = (uidToTitleMap_t *)cargo;
struct guide_nodedata_t *data =
(struct guide_nodedata_t *)tree_get_data(node);
CStringA rtf = data->text;
if (fixLinks(rtf, uidToTitleMapPtr))
guide_nodedata_set_text(data, rtf);
return 0;
}
int RTFConcatenator::CollectCallback(HTREEITEM item,
struct tree_node_t *node, void *cargo)
{
RTFConcatenator *that = (RTFConcatenator *)cargo;
struct guide_nodedata_t *data =
(struct guide_nodedata_t *)tree_get_data(node);
ASSERT(node);
ASSERT(cargo);
ASSERT(item);
// position cursor at end and clear selection
HWND hWnd = that->m_hWnd;
::SendMessage(hWnd, EM_SETSEL, (WPARAM)-1, (LPARAM)-1);
// get heading level
int level = 0; // 0 => no other top nodes
struct tree_node_t *node2 = node;
while (tree_get_parent(node2) != that->m_pTopNode)
{
level++;
node2 = tree_get_parent(node2);
}
// append heading rtf text
CStringA heading =
that->m_TemplateHelper.GetHeading(
that->m_HeadingCounter.GetHeadingNumber(node),
level,
data->title,
that->m_bLastTextEmpty,
data->color, data->bgcolor);
SETTEXTEX tex;
tex.codepage = CP_ACP; // ???
tex.flags = ST_SELECTION;
LRESULT lr = ::SendMessage(hWnd, EM_SETTEXTEX, (WPARAM)&tex, (LPARAM)(const char *)heading);
ASSERT(lr > 0);
// check the number of characters in the text
SetRTF(that->m_hZeroCheckWnd, data->text, false);
LRESULT nChars = ::SendMessage(that->m_hZeroCheckWnd, WM_GETTEXTLENGTH, 0, 0);
if (nChars > 0)
{
// append rtf text (only if some text is really present)
if (data->text[0] != 0 && strcmp(theEmptyRTFText, data->text) != 0) //theEmptyRTFText != data->text)
::SendMessage(hWnd, EM_SETTEXTEX, (WPARAM)&tex, (LPARAM)data->text);
}
that->m_bLastTextEmpty = (nChars == 0);
// continue
return 0;
}
void
redraw_file_info_dialog(void)
{
const dir_entry_t *entry;
char perm_buf[26];
char size_buf[56];
char buf[256];
#ifndef _WIN32
char id_buf[26];
#endif
int curr_y;
uint64_t size;
int size_not_precise;
assert(view != NULL);
if(resize_for_menu_like() != 0)
{
return;
}
werase(menu_win);
entry = &view->dir_entry[view->list_pos];
size = 0;
if(entry->type == FT_DIR)
{
char full_path[PATH_MAX];
get_current_full_path(view, sizeof(full_path), full_path);
tree_get_data(curr_stats.dirsize_cache, full_path, &size);
}
if(size == 0)
{
size = entry->size;
}
size_not_precise = friendly_size_notation(size, sizeof(size_buf), size_buf);
curr_y = 2;
curr_y += print_item("Path: ", entry->origin, curr_y);
curr_y += print_item("Name: ", entry->name, curr_y);
mvwaddstr(menu_win, curr_y, 2, "Size: ");
mvwaddstr(menu_win, curr_y, 8, size_buf);
if(size_not_precise)
{
snprintf(size_buf, sizeof(size_buf), " (%" PRId64 " bytes)", size);
waddstr(menu_win, size_buf);
}
curr_y += 2;
curr_y += show_file_type(view, curr_y);
curr_y += show_mime_type(view, curr_y);
#ifndef _WIN32
get_perm_string(perm_buf, sizeof(perm_buf), entry->mode);
curr_y += print_item("Permissions: ", perm_buf, curr_y);
#else
copy_str(perm_buf, sizeof(perm_buf), attr_str_long(entry->attrs));
curr_y += print_item("Attributes: ", perm_buf, curr_y);
#endif
format_time(entry->mtime, buf, sizeof(buf));
curr_y += print_item("Modified: ", buf, curr_y);
format_time(entry->atime, buf, sizeof(buf));
curr_y += print_item("Accessed: ", buf, curr_y);
format_time(entry->ctime, buf, sizeof(buf));
#ifndef _WIN32
curr_y += print_item("Changed: ", buf, curr_y);
#else
curr_y += print_item("Created: ", buf, curr_y);
#endif
#ifndef _WIN32
get_uid_string(entry, 0, sizeof(id_buf), id_buf);
curr_y += print_item("Owner: ", id_buf, curr_y);
get_gid_string(entry, 0, sizeof(id_buf), id_buf);
curr_y += print_item("Group: ", id_buf, curr_y);
#endif
/* Fake use after last assignment. */
(void)curr_y;
box(menu_win, 0, 0);
checked_wmove(menu_win, 0, 3);
wprint(menu_win, " File Information ");
wrefresh(menu_win);
was_redraw = 1;
}
void
redraw_file_info_dialog(void)
{
char name_buf[NAME_MAX];
char perm_buf[26];
char size_buf[56];
char buf[256];
#ifndef _WIN32
char uid_buf[26];
struct passwd *pwd_buf;
struct group *grp_buf;
#endif
struct tm *tm_ptr;
int curr_y;
uint64_t size;
int size_not_precise;
assert(view != NULL);
resize_for_menu_like();
werase(menu_win);
snprintf(name_buf, sizeof(name_buf), "%s",
view->dir_entry[view->list_pos].name);
size = 0;
if(view->dir_entry[view->list_pos].type == DIRECTORY)
tree_get_data(curr_stats.dirsize_cache,
view->dir_entry[view->list_pos].name, &size);
if(size == 0)
size = view->dir_entry[view->list_pos].size;
size_not_precise = friendly_size_notation(size, sizeof(size_buf), size_buf);
#ifndef _WIN32
if((pwd_buf = getpwuid(view->dir_entry[view->list_pos].uid)) == NULL)
{
snprintf(uid_buf, sizeof(uid_buf), "%d",
(int) view->dir_entry[view->list_pos].uid);
}
else
{
snprintf(uid_buf, sizeof(uid_buf), "%s", pwd_buf->pw_name);
}
get_perm_string(perm_buf, sizeof(perm_buf),
view->dir_entry[view->list_pos].mode);
#else
snprintf(perm_buf, sizeof(perm_buf), "%s",
attr_str_long(view->dir_entry[view->list_pos].attrs));
#endif
curr_y = 2;
mvwaddstr(menu_win, curr_y, 2, "File: ");
name_buf[getmaxx(menu_win) - 8] = '\0';
checked_wmove(menu_win, curr_y, 8);
wprint(menu_win, name_buf);
curr_y += 2;
mvwaddstr(menu_win, curr_y, 2, "Size: ");
mvwaddstr(menu_win, curr_y, 8, size_buf);
if(size_not_precise)
{
snprintf(size_buf, sizeof(size_buf), " (%" PRId64 " bytes)", size);
waddstr(menu_win, size_buf);
}
curr_y += 2;
curr_y += show_file_type(view, curr_y);
curr_y += show_mime_type(view, curr_y);
#ifndef _WIN32
mvwaddstr(menu_win, curr_y, 2, "Permissions: ");
#else
mvwaddstr(menu_win, curr_y, 2, "Attributes: ");
#endif
mvwaddstr(menu_win, curr_y, 15, perm_buf);
curr_y += 2;
mvwaddstr(menu_win, curr_y, 2, "Modified: ");
tm_ptr = localtime(&view->dir_entry[view->list_pos].mtime);
strftime(buf, sizeof (buf), "%a %b %d %Y %I:%M %p", tm_ptr);
checked_wmove(menu_win, curr_y, 13);
wprint(menu_win, buf);
curr_y += 2;
mvwaddstr(menu_win, curr_y, 2, "Accessed: ");
tm_ptr = localtime(&view->dir_entry[view->list_pos].atime);
strftime(buf, sizeof (buf), "%a %b %d %Y %I:%M %p", tm_ptr);
checked_wmove(menu_win, curr_y, 13);
wprint(menu_win, buf);
curr_y += 2;
#ifndef _WIN32
mvwaddstr(menu_win, curr_y, 2, "Changed: ");
#else
mvwaddstr(menu_win, curr_y, 2, "Created: ");
#endif
tm_ptr = localtime(&view->dir_entry[view->list_pos].ctime);
strftime(buf, sizeof (buf), "%a %b %d %Y %I:%M %p", tm_ptr);
checked_wmove(menu_win, curr_y, 13);
wprint(menu_win, buf);
curr_y += 2;
#ifndef _WIN32
mvwaddstr(menu_win, curr_y, 2, "Owner: ");
mvwaddstr(menu_win, curr_y, 10, uid_buf);
curr_y += 2;
mvwaddstr(menu_win, curr_y, 2, "Group: ");
if((grp_buf = getgrgid(view->dir_entry[view->list_pos].gid)) != NULL)
mvwaddstr(menu_win, curr_y, 10, grp_buf->gr_name);
#endif
box(menu_win, 0, 0);
checked_wmove(menu_win, 0, 3);
wprint(menu_win, " File Information ");
wrefresh(menu_win);
was_redraw = 1;
}
static int
sort_dir_list(const void *one, const void *two)
{
int retval;
char *pfirst, *psecond;
dir_entry_t *const first = (dir_entry_t *)one;
dir_entry_t *const second = (dir_entry_t *)two;
int first_is_dir;
int second_is_dir;
int dirs;
if(is_parent_dir(first->name))
{
return -1;
}
else if(is_parent_dir(second->name))
{
return 1;
}
first_is_dir = is_directory_entry(first);
second_is_dir = is_directory_entry(second);
dirs = first_is_dir || second_is_dir;
retval = 0;
switch(sort_type)
{
case SORT_BY_NAME:
case SORT_BY_INAME:
if(first->name[0] == '.' && second->name[0] != '.')
retval = -1;
else if(first->name[0] != '.' && second->name[0] == '.')
retval = 1;
else
retval = compare_file_names(dirs, first->name, second->name,
sort_type == SORT_BY_INAME);
break;
case SORT_BY_TYPE:
if(first_is_dir != second_is_dir)
{
retval = first_is_dir ? -1 : 1;
}
break;
case SORT_BY_EXTENSION:
pfirst = strrchr(first->name, '.');
psecond = strrchr(second->name, '.');
if(pfirst && psecond)
retval = compare_file_names(dirs, ++pfirst, ++psecond, 0);
else if(pfirst || psecond)
retval = pfirst ? -1 : 1;
else
retval = compare_file_names(dirs, first->name, second->name, 0);
break;
case SORT_BY_SIZE:
{
if(first_is_dir)
tree_get_data(curr_stats.dirsize_cache, first->name, &first->size);
if(second_is_dir)
tree_get_data(curr_stats.dirsize_cache, second->name, &second->size);
retval = (first->size < second->size) ?
-1 : (first->size > second->size);
}
break;
case SORT_BY_TIME_MODIFIED:
retval = first->mtime - second->mtime;
break;
case SORT_BY_TIME_ACCESSED:
retval = first->atime - second->atime;
break;
case SORT_BY_TIME_CHANGED:
retval = first->ctime - second->ctime;
break;
#ifndef _WIN32
case SORT_BY_MODE:
retval = first->mode - second->mode;
break;
case SORT_BY_OWNER_NAME: /* FIXME */
case SORT_BY_OWNER_ID:
retval = first->uid - second->uid;
break;
case SORT_BY_GROUP_NAME: /* FIXME */
case SORT_BY_GROUP_ID:
retval = first->gid - second->gid;
break;
case SORT_BY_PERMISSIONS:
{
char first_perm[11], second_perm[11];
get_perm_string(first_perm, sizeof(first_perm), first->mode);
get_perm_string(second_perm, sizeof(second_perm), second->mode);
retval = strcmp(first_perm, second_perm);
}
break;
#endif
default:
assert(0 && "All possible sort options should be handled");
break;
}
if(retval == 0)
{
retval = first->list_num - second->list_num;
}
else if(sort_descending)
{
retval = -retval;
}
return retval;
}
static int
sort_dir_list(const void *one, const void *two)
{
int retval;
char *pfirst, *psecond;
dir_entry_t *first = (dir_entry_t *) one;
dir_entry_t *second = (dir_entry_t *) two;
int first_is_dir = 0;
int second_is_dir = 0;
if(first->type == DIRECTORY)
first_is_dir = 1;
else if(first->type == LINK)
first_is_dir = (first->name[strlen(first->name) - 1] == '/');
if(second->type == DIRECTORY)
second_is_dir = 1;
else if(second->type == LINK)
second_is_dir = (second->name[strlen(second->name) - 1] == '/');
if(first_is_dir != second_is_dir)
return first_is_dir ? -1 : 1;
if(pathcmp(first->name, "../") == 0)
return -1;
else if(pathcmp(second->name, "../") == 0)
return 1;
retval = 0;
switch(sort_type)
{
case SORT_BY_NAME:
case SORT_BY_INAME:
if(first->name[0] == '.' && second->name[0] != '.')
retval = -1;
else if(first->name[0] != '.' && second->name[0] == '.')
retval = 1;
else
retval = compare_file_names(first->name, second->name,
sort_type == SORT_BY_INAME);
break;
case SORT_BY_EXTENSION:
pfirst = strrchr(first->name, '.');
psecond = strrchr(second->name, '.');
if(pfirst && psecond)
retval = compare_file_names(++pfirst, ++psecond, 0);
else if(pfirst || psecond)
retval = pfirst ? -1 : 1;
else
retval = compare_file_names(first->name, second->name, 0);
break;
case SORT_BY_SIZE:
{
if(first_is_dir)
tree_get_data(curr_stats.dirsize_cache, first->name, &first->size);
if(second_is_dir)
tree_get_data(curr_stats.dirsize_cache, second->name, &second->size);
retval = (first->size < second->size) ?
-1 : (first->size > second->size);
}
break;
case SORT_BY_TIME_MODIFIED:
retval = first->mtime - second->mtime;
break;
case SORT_BY_TIME_ACCESSED:
retval = first->atime - second->atime;
break;
case SORT_BY_TIME_CHANGED:
retval = first->ctime - second->ctime;
break;
#ifndef _WIN32
case SORT_BY_MODE:
retval = first->mode - second->mode;
break;
case SORT_BY_OWNER_NAME: /* FIXME */
case SORT_BY_OWNER_ID:
retval = first->uid - second->uid;
break;
case SORT_BY_GROUP_NAME: /* FIXME */
case SORT_BY_GROUP_ID:
retval = first->gid - second->gid;
break;
#endif
}
if(retval == 0)
retval = first->list_num - second->list_num;
else if(sort_descending)
retval = -retval;
return retval;
}
static int
sort_dir_list(const void *one, const void *two)
{
int retval;
char *pfirst, *psecond;
dir_entry_t *const first = (dir_entry_t *)one;
dir_entry_t *const second = (dir_entry_t *)two;
int first_is_dir;
int second_is_dir;
if(is_parent_dir(first->name))
{
return -1;
}
else if(is_parent_dir(second->name))
{
return 1;
}
first_is_dir = is_directory_entry(first);
second_is_dir = is_directory_entry(second);
retval = 0;
switch(sort_type)
{
case SK_BY_NAME:
case SK_BY_INAME:
if(custom_view)
{
retval = compare_entry_names(first, second, sort_type == SK_BY_INAME);
}
else
{
retval = compare_full_file_names(first->name, second->name,
sort_type == SK_BY_INAME);
}
break;
case SK_BY_DIR:
if(first_is_dir != second_is_dir)
{
retval = first_is_dir ? -1 : 1;
}
break;
case SK_BY_TYPE:
retval = strcmp(get_type_str(first->type), get_type_str(second->type));
break;
case SK_BY_FILEEXT:
case SK_BY_EXTENSION:
pfirst = strrchr(first->name, '.');
psecond = strrchr(second->name, '.');
if(first_is_dir && second_is_dir && sort_type == SK_BY_FILEEXT)
{
retval = compare_file_names(first->name, second->name, 0);
}
else if(first_is_dir != second_is_dir && sort_type == SK_BY_FILEEXT)
{
retval = first_is_dir ? -1 : 1;
}
else if(pfirst && psecond)
{
if(pfirst == first->name && psecond != second->name)
{
retval = -1;
}
else if(pfirst != first->name && psecond == second->name)
{
retval = 1;
}
else
{
retval = compare_file_names(++pfirst, ++psecond, 0);
}
}
else if(pfirst || psecond)
retval = pfirst ? -1 : 1;
else
retval = compare_file_names(first->name, second->name, 0);
break;
case SK_BY_SIZE:
{
if(first_is_dir)
{
char full_path[PATH_MAX];
get_full_path_of(first, sizeof(full_path), full_path);
tree_get_data(curr_stats.dirsize_cache, full_path, &first->size);
}
if(second_is_dir)
{
char full_path[PATH_MAX];
get_full_path_of(second, sizeof(full_path), full_path);
tree_get_data(curr_stats.dirsize_cache, full_path, &second->size);
}
retval = (first->size < second->size)
? -1
: (first->size > second->size);
}
break;
case SK_BY_TIME_MODIFIED:
retval = first->mtime - second->mtime;
break;
case SK_BY_TIME_ACCESSED:
retval = first->atime - second->atime;
break;
case SK_BY_TIME_CHANGED:
retval = first->ctime - second->ctime;
break;
#ifndef _WIN32
case SK_BY_MODE:
retval = first->mode - second->mode;
break;
case SK_BY_OWNER_NAME: /* FIXME */
case SK_BY_OWNER_ID:
retval = first->uid - second->uid;
break;
case SK_BY_GROUP_NAME: /* FIXME */
case SK_BY_GROUP_ID:
retval = first->gid - second->gid;
break;
case SK_BY_PERMISSIONS:
{
char first_perm[11], second_perm[11];
get_perm_string(first_perm, sizeof(first_perm), first->mode);
get_perm_string(second_perm, sizeof(second_perm), second->mode);
retval = strcmp(first_perm, second_perm);
}
break;
#endif
}
if(retval == 0)
{
retval = first->list_num - second->list_num;
}
else if(sort_descending)
{
retval = -retval;
}
return retval;
}
