winefile.c File Reference

#include "winefile.h"
#include "resource.h"
#include "wine/unicode.h"

Include dependency graph for winefile.c:

Go to the source code of this file.

Classes
struct	_Entry
struct	Root
	root entry for file system trees More...
struct	Pane
	child window pane for displaying file lists More...
struct	ChildWnd
struct	FilterDialog
struct	PropertiesDialog
struct	LANGANDCODEPAGE
struct	FullScreenParameters

Macros
#define	COBJMACROS
#define	_MAX_DRIVE   3
#define	_MAX_FNAME   256
#define	_MAX_DIR   _MAX_FNAME
#define	_MAX_EXT   _MAX_FNAME
#define	_MAX_PATH   260
#define	UNION_MEMBER(x)   DUMMYUNIONNAME.x
#define	DEFAULT_SPLIT_POS   300
#define	COLUMNS   10
#define	RS(b, i)   load_string(b, sizeof(b)/sizeof(b[0]), i)
#define	FETCH_ITEM_COUNT   32
#define	RFF_NODEFAULT   0x02 /* No default item selected. */

Typedefs
typedef struct _Entry	Entry

Enumerations
enum	ENTRY_TYPE {   ET_UNKNOWN, ET_WINDOWS, ET_SHELL, ET_NTOBJS,   ET_REGISTRY, ET_FAT, ET_WEB, ET_WINDOWS,   ET_UNIX, ET_SHELL }
enum	COLUMN_FLAGS {   COL_TYPE = 0x0001, COL_SIZE = 0x0002, COL_DATE = 0x0004, COL_TIME = 0x0008,   COL_ATTRIBUTES = 0x0010, COL_DOSNAMES = 0x0020, COL_INDEX = 0x0040, COL_LINKS = 0x0080,   COL_CONTENT = 0x0100, COL_ALL = COL_TYPE|COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_DOSNAMES|COL_INDEX|COL_LINKS|COL_CONTENT, COL_SIZE = 0x01, COL_DATE = 0x02,   COL_TIME = 0x04, COL_ATTRIBUTES = 0x08, COL_DOSNAMES = 0x10, COL_INDEX = 0x20,   COL_LINKS = 0x40, COL_ALL = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_DOSNAMES|COL_INDEX|COL_LINKS }
enum	SORT_ORDER {   SORT_NONE, SORT_NAME, SORT_EXT, SORT_SIZE,   SORT_DATE, SORT_NAME, SORT_EXT, SORT_SIZE,   SORT_DATE }
enum	TYPE_ORDER {   TO_DIR, TO_DOT, TO_DOTDOT, TO_OTHER_DIR,   TO_VIRTUAL_FOLDER, TO_FILE, TO_DIR = 0, TO_DOT = 1,   TO_DOTDOT = 2, TO_OTHER_DIR = 3, TO_FILE = 4 }
enum	TYPE_FILTER {   TF_DIRECTORIES = 0x01, TF_PROGRAMS = 0x02, TF_DOCUMENTS = 0x04, TF_OTHERS = 0x08,   TF_HIDDEN = 0x10, TF_ALL = 0x1F }
enum	FILE_TYPE { FT_OTHER = 0, FT_EXECUTABLE = 1, FT_DOCUMENT = 2 }

Functions
static void	read_directory (Entry *dir, LPCWSTR path, SORT_ORDER sortOrder, HWND hwnd)
static void	set_curdir (ChildWnd *child, Entry *entry, int idx, HWND hwnd)
static void	refresh_child (ChildWnd *child)
static void	refresh_drives (void)
static void	get_path (Entry *dir, PWSTR path)
static void	format_date (const FILETIME *ft, WCHAR *buffer, int visible_cols)
static LRESULT CALLBACK	FrameWndProc (HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
static LRESULT CALLBACK	ChildWndProc (HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
static LRESULT CALLBACK	TreeWndProc (HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
static void	format_longlong (LPWSTR ret, ULONGLONG val)
static LPWSTR	load_string (LPWSTR buffer, DWORD size, UINT id)
static void	display_error (HWND hwnd, DWORD error)
static void	display_network_error (HWND hwnd)
static BOOL	get_check (HWND hwnd, INT id)
static INT	set_check (HWND hwnd, INT id, BOOL on)
static void	choose_font (HWND hwnd)
static Entry *	alloc_entry (void)
static void	free_entry (Entry *entry)
static void	free_entries (Entry *dir)
static void	read_directory_win (Entry *dir, LPCWSTR path)
static Entry *	find_entry_win (Entry *dir, LPCWSTR name)
static Entry *	read_tree_win (Root *root, LPCWSTR path, SORT_ORDER sortOrder, HWND hwnd)
static void	free_strret (STRRET *str)
static LPWSTR	wcscpyn (LPWSTR dest, LPCWSTR source, size_t count)
static void	get_strretW (STRRET *str, const SHITEMID *shiid, LPWSTR buffer, int len)
static HRESULT	name_from_pidl (IShellFolder *folder, LPITEMIDLIST pidl, LPWSTR buffer, int len, SHGDNF flags)
static HRESULT	path_from_pidlW (IShellFolder *folder, LPITEMIDLIST pidl, LPWSTR buffer, int len)
static LPITEMIDLIST	get_path_pidl (LPWSTR path, HWND hwnd)
static LPITEMIDLIST	get_to_absolute_pidl (Entry *entry, HWND hwnd)
static HICON	extract_icon (IShellFolder *folder, LPCITEMIDLIST pidl)
static Entry *	find_entry_shell (Entry *dir, LPCITEMIDLIST pidl)
static Entry *	read_tree_shell (Root *root, LPITEMIDLIST pidl, SORT_ORDER sortOrder, HWND hwnd)
static void	fill_w32fdata_shell (IShellFolder *folder, LPCITEMIDLIST pidl, SFGAOF attribs, WIN32_FIND_DATAW *w32fdata)
static void	read_directory_shell (Entry *dir, HWND hwnd)
static int	TypeOrderFromDirname (LPCWSTR name)
static int	compareType (const WIN32_FIND_DATAW *fd1, const WIN32_FIND_DATAW *fd2)
static int	compareName (const void *arg1, const void *arg2)
static int	compareExt (const void *arg1, const void *arg2)
static int	compareSize (const void *arg1, const void *arg2)
static int	compareDate (const void *arg1, const void *arg2)
static void	SortDirectory (Entry *dir, SORT_ORDER sortOrder)
static Entry *	read_tree (Root *root, LPCWSTR path, LPITEMIDLIST pidl, LPWSTR drv, SORT_ORDER sortOrder, HWND hwnd)
static ChildWnd *	alloc_child_window (LPCWSTR path, LPITEMIDLIST pidl, HWND hwnd)
static void	free_child_window (ChildWnd *child)
static windowOptions	load_registry_settings (void)
static void	save_registry_settings (void)
static void	resize_frame_rect (HWND hwnd, PRECT prect)
static void	resize_frame (HWND hwnd, int cx, int cy)
static void	resize_frame_client (HWND hwnd)
static LRESULT CALLBACK	CBTProc (int code, WPARAM wparam, LPARAM lparam)
static HWND	create_child_window (ChildWnd *child)
static void	WineFile_OnRun (HWND hwnd)
static INT_PTR CALLBACK	DestinationDlgProc (HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
static INT_PTR CALLBACK	FilterDialogDlgProc (HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
static void	PropDlg_DisplayValue (HWND hlbox, HWND hedit)
static void	CheckForFileInfo (struct PropertiesDialog *dlg, HWND hwnd, LPCWSTR strFilename)
static INT_PTR CALLBACK	PropertiesDialogDlgProc (HWND hwnd, UINT nmsg, WPARAM wparam, LPARAM lparam)
static void	show_properties_dlg (Entry *entry, HWND hwnd)
static void	frame_get_clientspace (HWND hwnd, PRECT prect)
static BOOL	toggle_fullscreen (HWND hwnd)
static void	fullscreen_move (HWND hwnd)
static void	toggle_child (HWND hwnd, UINT cmd, HWND hchild)
static BOOL	activate_drive_window (LPCWSTR path)
static BOOL	activate_fs_window (LPCWSTR filesys)
static void	resize_tree (ChildWnd *child, int cx, int cy)
static HWND	create_header (HWND parent, Pane *pane, UINT id)
static void	init_output (HWND hwnd)
static void	draw_item (Pane *pane, LPDRAWITEMSTRUCT dis, Entry *entry, int calcWidthCol)
static BOOL	calc_widths (Pane *pane, BOOL anyway)
static void	calc_single_width (Pane *pane, int col)
static BOOL	pattern_match (LPCWSTR str, LPCWSTR pattern)
static BOOL	pattern_imatch (LPCWSTR str, LPCWSTR pattern)
static enum FILE_TYPE	get_file_type (LPCWSTR filename)
static int	insert_entries (Pane *pane, Entry *dir, LPCWSTR pattern, int filter_flags, int idx)
static void	format_bytes (LPWSTR buffer, LONGLONG bytes)
static void	set_space_status (void)
static void	create_tree_window (HWND parent, Pane *pane, UINT id, UINT id_header, LPCWSTR pattern, int filter_flags)
static void	InitChildWindow (ChildWnd *child)
static void	calc_width (Pane *pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str)
static void	calc_tabbed_width (Pane *pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str)
static void	output_text (Pane *pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str, DWORD flags)
static void	output_tabbed_text (Pane *pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str)
static void	output_number (Pane *pane, LPDRAWITEMSTRUCT dis, int col, LPCWSTR str)
static BOOL	is_exe_file (LPCWSTR ext)
static BOOL	is_registered_type (LPCWSTR ext)
static void	set_header (Pane *pane)
static LRESULT	pane_notify (Pane *pane, NMHDR *pnmh)
static void	scan_entry (ChildWnd *child, Entry *entry, int idx, HWND hwnd)
static BOOL	expand_entry (ChildWnd *child, Entry *dir)
static void	collapse_entry (Pane *pane, Entry *dir)
static void	refresh_right_pane (ChildWnd *child)
static void	create_drive_bar (void)
static BOOL	launch_file (HWND hwnd, LPCWSTR cmd, UINT nCmdShow)
static BOOL	launch_entry (Entry *entry, HWND hwnd, UINT nCmdShow)
static void	activate_entry (ChildWnd *child, Pane *pane, HWND hwnd)
static BOOL	pane_command (Pane *pane, UINT cmd)
static void	set_sort_order (ChildWnd *child, SORT_ORDER sortOrder)
static void	update_view_menu (ChildWnd *child)
static BOOL	is_directory (LPCWSTR target)
static BOOL	prompt_target (Pane *pane, LPWSTR source, LPWSTR target)
static void	CtxMenu_reset (void)
static IContextMenu *	CtxMenu_query_interfaces (IContextMenu *pcm1)
static BOOL	CtxMenu_HandleMenuMsg (UINT nmsg, WPARAM wparam, LPARAM lparam)
static HRESULT	ShellFolderContextMenu (IShellFolder *shell_folder, HWND hwndParent, int cidl, LPCITEMIDLIST *apidl, int x, int y)
static void	InitInstance (HINSTANCE hinstance)
static BOOL	show_frame (HWND hwndParent, int cmdshow, LPCWSTR path)
static void	ExitInstance (void)
int APIENTRY	wWinMain (HINSTANCE hinstance, HINSTANCE previnstance, LPWSTR cmdline, int cmdshow)

Variables
static const WCHAR	registry_key []
static const WCHAR	reg_start_x [] = { 's','t','a','r','t','X','\0'}
static const WCHAR	reg_start_y [] = { 's','t','a','r','t','Y','\0'}
static const WCHAR	reg_width [] = { 'w','i','d','t','h','\0'}
static const WCHAR	reg_height [] = { 'h','e','i','g','h','t','\0'}
static const WCHAR	reg_logfont [] = { 'l','o','g','f','o','n','t','\0'}
WINEFILE_GLOBALS	Globals
static int	last_split
static const WCHAR	sEmpty [] = {'\0'}
static const WCHAR	sSpace [] = {' ', '\0'}
static const WCHAR	sNumFmt [] = {'%','d','\0'}
static const WCHAR	sQMarks [] = {'?','?','?','\0'}
static const WCHAR	sWINEFILEFRAME [] = {'W','F','S','_','F','r','a','m','e','\0'}
static const WCHAR	sWINEFILETREE [] = {'W','F','S','_','T','r','e','e','\0'}
static int(*	sortFunctions [])(const void *arg1, const void *arg2)
static HHOOK	hcbthook
static ChildWnd *	newchild = NULL
struct LANGANDCODEPAGE *	lpTranslate
static LPCSTR	InfoStrings []
static struct FullScreenParameters	g_fullscreen
static WCHAR	g_pos_names [COLUMNS][40]
static const int	g_pos_align []
static WNDPROC	g_orgTreeWndProc
static IContextMenu2 *	s_pctxmenu2 = NULL
static IContextMenu3 *	s_pctxmenu3 = NULL

Macro Definition Documentation

#define _MAX_DIR   _MAX_FNAME

Definition at line 41 of file winefile.c.

Referenced by alloc_child_window(), read_tree(), and show_frame().

#define _MAX_DRIVE   3

Definition at line 39 of file winefile.c.

Referenced by activate_drive_window(), alloc_child_window(), FrameWndProc(), refresh_child(), and show_frame().

#define _MAX_EXT   _MAX_FNAME

Definition at line 42 of file winefile.c.

Referenced by alloc_child_window(), is_exe_file(), prompt_target(), and show_frame().

#define _MAX_FNAME   256

Definition at line 40 of file winefile.c.

Referenced by alloc_child_window(), prompt_target(), read_tree(), and show_frame().

#define _MAX_PATH   260

Definition at line 43 of file winefile.c.

Referenced by extract_icon().

#define COBJMACROS

Definition at line 32 of file winefile.c.

#define COLUMNS   10

Definition at line 119 of file winefile.c.

Referenced by calc_single_width(), calc_widths(), create_header(), draw_item(), pane_notify(), and set_header().

#define DEFAULT_SPLIT_POS   300

Definition at line 52 of file winefile.c.

Referenced by alloc_child_window().

#define FETCH_ITEM_COUNT   32

Referenced by read_directory_shell().

#define RFF_NODEFAULT   0x02 /* No default item selected. */

Definition at line 1630 of file winefile.c.

Referenced by WineFile_OnRun().

#define RS	(		b,
			i
	)		load_string(b, sizeof(b)/sizeof(b[0]), i)

Definition at line 195 of file winefile.c.

Referenced by DestinationDlgProc(), display_error(), display_network_error(), FrameWndProc(), set_space_status(), and show_frame().

#define UNION_MEMBER

(

x

)

DUMMYUNIONNAME.x

Definition at line 47 of file winefile.c.

Typedef Documentation

_Inout_ PLIST_ENTRY Entry

Definition at line 640 of file kefuncs.h.

Enumeration Type Documentation

enum COLUMN_FLAGS

Enumerator
COL_TYPE
COL_SIZE
COL_DATE
COL_TIME
COL_ATTRIBUTES
COL_DOSNAMES
COL_INDEX
COL_LINKS
COL_CONTENT
COL_ALL
COL_SIZE
COL_DATE
COL_TIME
COL_ATTRIBUTES
COL_DOSNAMES
COL_INDEX
COL_LINKS
COL_ALL

Definition at line 97 of file winefile.c.

                  {
    COL_SIZE        = 0x01,
    COL_DATE        = 0x02,
    COL_TIME        = 0x04,
    COL_ATTRIBUTES  = 0x08,
    COL_DOSNAMES    = 0x10,
    COL_INDEX       = 0x20,
    COL_LINKS       = 0x40,
    COL_ALL = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_DOSNAMES|COL_INDEX|COL_LINKS
};

enum ENTRY_TYPE

Enumerator
ET_UNKNOWN
ET_WINDOWS
ET_SHELL
ET_NTOBJS
ET_REGISTRY
ET_FAT
ET_WEB
ET_WINDOWS
ET_UNIX
ET_SHELL

Definition at line 63 of file winefile.c.

                {
    ET_WINDOWS,
    ET_UNIX,
    ET_SHELL
};

enum FILE_TYPE

Enumerator
FT_OTHER
FT_EXECUTABLE
FT_DOCUMENT

Definition at line 2568 of file winefile.c.

               {
    FT_OTHER        = 0,
    FT_EXECUTABLE   = 1,
    FT_DOCUMENT     = 2
};

enum SORT_ORDER

Enumerator
SORT_NONE
SORT_NAME
SORT_EXT
SORT_SIZE
SORT_DATE
SORT_NAME
SORT_EXT
SORT_SIZE
SORT_DATE

Definition at line 108 of file winefile.c.

             {
    SORT_NAME,
    SORT_EXT,
    SORT_SIZE,
    SORT_DATE
} SORT_ORDER;

enum TYPE_FILTER

Enumerator
TF_DIRECTORIES
TF_PROGRAMS
TF_DOCUMENTS
TF_OTHERS
TF_HIDDEN
TF_ALL

Definition at line 1282 of file winefile.c.

                 {
    TF_DIRECTORIES  = 0x01,
    TF_PROGRAMS     = 0x02,
    TF_DOCUMENTS    = 0x04,
    TF_OTHERS       = 0x08,
    TF_HIDDEN       = 0x10,
    TF_ALL          = 0x1F
};

enum TYPE_ORDER

Enumerator
TO_DIR
TO_DOT
TO_DOTDOT
TO_OTHER_DIR
TO_VIRTUAL_FOLDER
TO_FILE
TO_DIR
TO_DOT
TO_DOTDOT
TO_OTHER_DIR
TO_FILE

Definition at line 998 of file winefile.c.

                {
    TO_DIR = 0,
    TO_DOT = 1,
    TO_DOTDOT = 2,
    TO_OTHER_DIR = 3,
    TO_FILE = 4
};

Function Documentation

static BOOL activate_drive_window ( LPCWSTR  path )

static

Definition at line 2009 of file winefile.c.

Referenced by FrameWndProc().

{
    WCHAR drv1[_MAX_DRIVE], drv2[_MAX_DRIVE];
    HWND child_wnd;

    _wsplitpath(path, drv1, 0, 0, 0);

        /* search for an already open window for the same drive */
    for(child_wnd=GetNextWindow(Globals.hmdiclient,GW_CHILD); child_wnd; child_wnd=GetNextWindow(child_wnd, GW_HWNDNEXT)) {
        ChildWnd* child = (ChildWnd*)GetWindowLongPtrW(child_wnd, GWLP_USERDATA);

        if (child) {
            _wsplitpath(child->root.path, drv2, 0, 0, 0);

            if (!lstrcmpiW(drv2, drv1)) {
                SendMessageW(Globals.hmdiclient, WM_MDIACTIVATE, (WPARAM)child_wnd, 0);

                if (IsIconic(child_wnd))
                    ShowWindow(child_wnd, SW_SHOWNORMAL);

                return TRUE;
            }
        }
    }

    return FALSE;
}

static void activate_entry ( ChildWnd *  child, Pane *  pane, HWND  hwnd  )

static

Definition at line 3570 of file winefile.c.

Referenced by ChildWndProc().

{
    Entry* entry = pane->cur;

    if (!entry)
        return;

    if (entry->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
        int scanned_old = entry->scanned;

        if (!scanned_old)
        {
            int idx = SendMessageW(child->left.hwnd, LB_GETCURSEL, 0, 0);
            scan_entry(child, entry, idx, hwnd);
        }

        if (entry->data.cFileName[0]=='.' && entry->data.cFileName[1]=='\0')
            return;

        if (entry->data.cFileName[0]=='.' && entry->data.cFileName[1]=='.' && entry->data.cFileName[2]=='\0') {
            entry = child->left.cur->up;
            collapse_entry(&child->left, entry);
            goto focus_entry;
        } else if (entry->expanded)
            collapse_entry(pane, child->left.cur);
        else {
            expand_entry(child, child->left.cur);

            if (!pane->treePane) focus_entry: {
                int idxstart = SendMessageW(child->left.hwnd, LB_GETCURSEL, 0, 0);
                int idx = SendMessageW(child->left.hwnd, LB_FINDSTRING, idxstart, (LPARAM)entry);
                SendMessageW(child->left.hwnd, LB_SETCURSEL, idx, 0);
                set_curdir(child, entry, idx, hwnd);
            }
        }

        if (!scanned_old) {
            calc_widths(pane, FALSE);

            set_header(pane);
        }
    } else {
        if (GetKeyState(VK_MENU) < 0)
            show_properties_dlg(entry, child->hwnd);
        else
            launch_entry(entry, child->hwnd, SW_SHOWNORMAL);
    }
}

static BOOL activate_fs_window ( LPCWSTR  filesys )

static

Definition at line 2037 of file winefile.c.

Referenced by FrameWndProc().

{
    HWND child_wnd;

        /* search for an already open window of the given file system name */
    for(child_wnd=GetNextWindow(Globals.hmdiclient,GW_CHILD); child_wnd; child_wnd=GetNextWindow(child_wnd, GW_HWNDNEXT)) {
        ChildWnd* child = (ChildWnd*) GetWindowLongPtrW(child_wnd, GWLP_USERDATA);

        if (child) {
            if (!lstrcmpiW(child->root.fs, filesys)) {
                SendMessageW(Globals.hmdiclient, WM_MDIACTIVATE, (WPARAM)child_wnd, 0);

                if (IsIconic(child_wnd))
                    ShowWindow(child_wnd, SW_SHOWNORMAL);

                return TRUE;
            }
        }
    }

    return FALSE;
}

static ChildWnd* alloc_child_window ( LPCWSTR  path, LPITEMIDLIST  pidl, HWND  hwnd  )

static

Definition at line 1292 of file winefile.c.

Referenced by ChildWndProc(), FrameWndProc(), and show_frame().

{
    WCHAR drv[_MAX_DRIVE+1], dir[_MAX_DIR], name[_MAX_FNAME], ext[_MAX_EXT];
    WCHAR dir_path[MAX_PATH];
    static const WCHAR sAsterics[] = {'*', '\0'};
    static const WCHAR sTitleFmt[] = {'%','s',' ','-',' ','%','s','\0'};

    ChildWnd* child = HeapAlloc(GetProcessHeap(), 0, sizeof(ChildWnd));
    Root* root = &child->root;
    Entry* entry;

    memset(child, 0, sizeof(ChildWnd));

    child->left.treePane = TRUE;
    child->left.visible_cols = 0;

    child->right.treePane = FALSE;
    child->right.visible_cols = COL_SIZE|COL_DATE|COL_TIME|COL_ATTRIBUTES|COL_INDEX|COL_LINKS;

    child->pos.length = sizeof(WINDOWPLACEMENT);
    child->pos.flags = 0;
    child->pos.showCmd = SW_SHOWNORMAL;
    child->pos.rcNormalPosition.left = CW_USEDEFAULT;
    child->pos.rcNormalPosition.top = CW_USEDEFAULT;
    child->pos.rcNormalPosition.right = CW_USEDEFAULT;
    child->pos.rcNormalPosition.bottom = CW_USEDEFAULT;

    child->focus_pane = 0;
    child->split_pos = DEFAULT_SPLIT_POS;
    child->sortOrder = SORT_NAME;
    child->header_wdths_ok = FALSE;

    if (path)
    {
        int pathlen = strlenW(path);
        const WCHAR *npath = path;

        if (path[0] == '"' && path[pathlen - 1] == '"')
        {
            npath++;
            pathlen--;
        }
        lstrcpynW(child->path, npath, pathlen + 1);
        
        _wsplitpath(child->path, drv, dir, name, ext);
    }

    lstrcpyW(child->filter_pattern, sAsterics);
    child->filter_flags = TF_ALL;

    root->entry.level = 0;

    lstrcpyW(dir_path, drv);
    lstrcatW(dir_path, dir);
    entry = read_tree(root, dir_path, pidl, drv, child->sortOrder, hwnd);

    if (root->entry.etype == ET_SHELL)
        load_string(root->entry.data.cFileName, sizeof(root->entry.data.cFileName)/sizeof(root->entry.data.cFileName[0]), IDS_DESKTOP);
    else
        wsprintfW(root->entry.data.cFileName, sTitleFmt, drv, root->fs);

    root->entry.data.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;

    child->left.root = &root->entry;
    child->right.root = NULL;

    set_curdir(child, entry, 0, hwnd);

    return child;
}

static Entry* alloc_entry ( void  )

static

Definition at line 292 of file winefile.c.

Referenced by read_directory_shell(), and read_directory_win().

{
    Entry* entry = HeapAlloc(GetProcessHeap(), 0, sizeof(Entry));

    entry->pidl = NULL;
    entry->folder = NULL;
    entry->hicon = 0;

    return entry;
}

static void calc_single_width ( Pane *  pane, int  col  )

static

Definition at line 2471 of file winefile.c.

Referenced by pane_notify().

{
    HFONT hfontOld;
    int x, cx;
    int entries = SendMessageW(pane->hwnd, LB_GETCOUNT, 0, 0);
    int cnt;
    HDC hdc;

    pane->widths[col] = 0;

    hdc = GetDC(pane->hwnd);
    hfontOld = SelectObject(hdc, Globals.hfont);

    for(cnt=0; cnt<entries; cnt++) {
        Entry* entry = (Entry*)SendMessageW(pane->hwnd, LB_GETITEMDATA, cnt, 0);
        DRAWITEMSTRUCT dis;

        dis.CtlType       = 0;
        dis.CtlID         = 0;
        dis.itemID        = 0;
        dis.itemAction    = 0;
        dis.itemState     = 0;
        dis.hwndItem      = pane->hwnd;
        dis.hDC           = hdc;
        dis.rcItem.left   = 0;
        dis.rcItem.top    = 0;
        dis.rcItem.right  = 0;
        dis.rcItem.bottom = 0;
        /*dis.itemData    = 0; */

        draw_item(pane, &dis, entry, col);
    }

    SelectObject(hdc, hfontOld);
    ReleaseDC(pane->hwnd, hdc);

    cx = pane->widths[col];

    if (cx) {
        cx += 3*Globals.spaceSize.cx;

        if (cx < IMAGE_WIDTH)
            cx = IMAGE_WIDTH;
    }

    pane->widths[col] = cx;

    x = pane->positions[col] + cx;

    for(; col<COLUMNS-1; ) {
        pane->positions[++col] = x;
        x += pane->widths[col];
    }

    SendMessageW(pane->hwnd, LB_SETHORIZONTALEXTENT, x, 0);
}

static void calc_tabbed_width ( Pane *  pane, LPDRAWITEMSTRUCT  dis, int  col, LPCWSTR  str  )

static

Definition at line 2786 of file winefile.c.

Referenced by draw_item().

{
    RECT rt = {0, 0, 0, 0};

    DrawTextW(dis->hDC, str, -1, &rt, DT_CALCRECT|DT_SINGLELINE|DT_EXPANDTABS|DT_TABSTOP|(2<<8));
    /*FIXME rt (0,0) ??? */

    if (rt.right > pane->widths[col])
        pane->widths[col] = rt.right;
}

static void calc_width ( Pane *  pane, LPDRAWITEMSTRUCT  dis, int  col, LPCWSTR  str  )

static

Definition at line 2776 of file winefile.c.

Referenced by draw_item().

{
    RECT rt = {0, 0, 0, 0};

    DrawTextW(dis->hDC, str, -1, &rt, DT_CALCRECT|DT_SINGLELINE|DT_NOPREFIX);

    if (rt.right > pane->widths[col])
        pane->widths[col] = rt.right;
}

static BOOL calc_widths ( Pane *  pane, BOOL  anyway  )

static

Definition at line 2386 of file winefile.c.

Referenced by activate_entry(), create_tree_window(), expand_entry(), pane_command(), refresh_right_pane(), and scan_entry().

{
    int col, x, cx, spc=3*Globals.spaceSize.cx;
    int entries = SendMessageW(pane->hwnd, LB_GETCOUNT, 0, 0);
    int orgWidths[COLUMNS];
    int orgPositions[COLUMNS+1];
    HFONT hfontOld;
    HDC hdc;
    int cnt;

    if (!anyway) {
        memcpy(orgWidths, pane->widths, sizeof(orgWidths));
        memcpy(orgPositions, pane->positions, sizeof(orgPositions));
    }

    for(col=0; col<COLUMNS; col++)
        pane->widths[col] = 0;

    hdc = GetDC(pane->hwnd);
    hfontOld = SelectObject(hdc, Globals.hfont);

    for(cnt=0; cnt<entries; cnt++) {
        Entry* entry = (Entry*)SendMessageW(pane->hwnd, LB_GETITEMDATA, cnt, 0);

        DRAWITEMSTRUCT dis;

        dis.CtlType       = 0;
        dis.CtlID         = 0;
        dis.itemID        = 0;
        dis.itemAction    = 0;
        dis.itemState     = 0;
        dis.hwndItem      = pane->hwnd;
        dis.hDC           = hdc;
        dis.rcItem.left   = 0;
        dis.rcItem.top    = 0;
        dis.rcItem.right  = 0;
        dis.rcItem.bottom = 0;
        /*dis.itemData    = 0; */

        draw_item(pane, &dis, entry, COLUMNS);
    }

    SelectObject(hdc, hfontOld);
    ReleaseDC(pane->hwnd, hdc);

    x = 0;
    for(col=0; col<COLUMNS; col++) {
        pane->positions[col] = x;
        cx = pane->widths[col];

        if (cx) {
            cx += spc;

            if (cx < IMAGE_WIDTH)
                cx = IMAGE_WIDTH;

            pane->widths[col] = cx;
        }

        x += cx;
    }

    pane->positions[COLUMNS] = x;

    SendMessageW(pane->hwnd, LB_SETHORIZONTALEXTENT, x, 0);

    /* no change? */
    if (!anyway && !memcmp(orgWidths, pane->widths, sizeof(orgWidths)))
        return FALSE;

    /* don't move, if only collapsing an entry */
    if (!anyway && pane->widths[0]<orgWidths[0] &&
        !memcmp(orgWidths+1, pane->widths+1, sizeof(orgWidths)-sizeof(int))) {
        pane->widths[0] = orgWidths[0];
        memcpy(pane->positions, orgPositions, sizeof(orgPositions));

        return FALSE;
    }

    InvalidateRect(pane->hwnd, 0, TRUE);

    return TRUE;
}

static LRESULT CALLBACK CBTProc ( int  code, WPARAM  wparam, LPARAM  lparam  )

static

Definition at line 1582 of file winefile.c.

Referenced by create_child_window().

{
    if (code==HCBT_CREATEWND && newchild) {
        ChildWnd* child = newchild;
        newchild = NULL;

        child->hwnd = (HWND) wparam;
        SetWindowLongPtrW(child->hwnd, GWLP_USERDATA, (LPARAM)child);
    }

    return CallNextHookEx(hcbthook, code, wparam, lparam);
}

static void CheckForFileInfo ( struct PropertiesDialog *  dlg, HWND  hwnd, LPCWSTR  strFilename  )

static

Definition at line 1766 of file winefile.c.

Referenced by PropertiesDialogDlgProc().

{
    static const WCHAR sBackSlash[] = {'\\','\0'};
    static const WCHAR sTranslation[] = {'\\','V','a','r','F','i','l','e','I','n','f','o','\\','T','r','a','n','s','l','a','t','i','o','n','\0'};
    static const WCHAR sStringFileInfo[] = {'\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o','\\',
                                        '%','0','4','x','%','0','4','x','\\','%','s','\0'};
        static const WCHAR sFmt[] = {'%','d','.','%','d','.','%','d','.','%','d','\0'};
    DWORD dwVersionDataLen = GetFileVersionInfoSizeW(strFilename, NULL);

    if (dwVersionDataLen) {
        dlg->pVersionData = HeapAlloc(GetProcessHeap(), 0, dwVersionDataLen);

        if (GetFileVersionInfoW(strFilename, 0, dwVersionDataLen, dlg->pVersionData)) {
            LPVOID pVal;
            UINT nValLen;

            if (VerQueryValueW(dlg->pVersionData, sBackSlash, &pVal, &nValLen)) {
                if (nValLen == sizeof(VS_FIXEDFILEINFO)) {
                    VS_FIXEDFILEINFO* pFixedFileInfo = (VS_FIXEDFILEINFO*)pVal;
                                        WCHAR buffer[BUFFER_LEN];

                                        sprintfW(buffer, sFmt,
                                                 HIWORD(pFixedFileInfo->dwFileVersionMS), LOWORD(pFixedFileInfo->dwFileVersionMS),
                                                 HIWORD(pFixedFileInfo->dwFileVersionLS), LOWORD(pFixedFileInfo->dwFileVersionLS));

                                        SetDlgItemTextW(hwnd, IDC_STATIC_PROP_VERSION, buffer);
                }
            }

            /* Read the list of languages and code pages. */
            if (VerQueryValueW(dlg->pVersionData, sTranslation, &pVal, &nValLen)) {
                struct LANGANDCODEPAGE* pTranslate = (struct LANGANDCODEPAGE*)pVal;
                struct LANGANDCODEPAGE* pEnd = (struct LANGANDCODEPAGE*)((LPBYTE)pVal+nValLen);

                HWND hlbox = GetDlgItem(hwnd, IDC_LIST_PROP_VERSION_TYPES);

                /* Read the file description for each language and code page. */
                for(; pTranslate<pEnd; ++pTranslate) {
                    LPCSTR* p;

                    for(p=InfoStrings; *p; ++p) {
                        WCHAR subblock[200];
                        WCHAR infoStr[100];
                        LPCWSTR pTxt;
                        UINT nValLen;

                        LPCSTR pInfoString = *p;
                        MultiByteToWideChar(CP_ACP, 0, pInfoString, -1, infoStr, 100);
                        wsprintfW(subblock, sStringFileInfo, pTranslate->wLanguage, pTranslate->wCodePage, infoStr);

                        /* Retrieve file description for language and code page */
                        if (VerQueryValueW(dlg->pVersionData, subblock, (PVOID)&pTxt, &nValLen)) {
                            int idx = SendMessageW(hlbox, LB_ADDSTRING, 0L, (LPARAM)infoStr);
                            SendMessageW(hlbox, LB_SETITEMDATA, idx, (LPARAM)pTxt);
                        }
                    }
                }

                SendMessageW(hlbox, LB_SETCURSEL, 0, 0);

                PropDlg_DisplayValue(hlbox, GetDlgItem(hwnd,IDC_LIST_PROP_VERSION_VALUES));
            }
        }
    }
}

static LRESULT CALLBACK ChildWndProc ( HWND  hwnd, UINT  nmsg, WPARAM  wparam, LPARAM  lparam  )

static

Definition at line 3814 of file winefile.c.

Referenced by InitInstance().

{
    ChildWnd* child = (ChildWnd*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
    ASSERT(child);

    switch(nmsg) {
        case WM_DRAWITEM: {
            LPDRAWITEMSTRUCT dis = (LPDRAWITEMSTRUCT)lparam;
            Entry* entry = (Entry*) dis->itemData;

            if (dis->CtlID == IDW_TREE_LEFT)
                draw_item(&child->left, dis, entry, -1);
            else if (dis->CtlID == IDW_TREE_RIGHT)
                draw_item(&child->right, dis, entry, -1);
            else
                goto draw_menu_item;

            return TRUE;}

        case WM_CREATE:
            InitChildWindow(child);
            break;

        case WM_NCDESTROY:
            free_child_window(child);
            SetWindowLongPtrW(hwnd, GWLP_USERDATA, 0);
            break;

        case WM_PAINT: {
            PAINTSTRUCT ps;
            HBRUSH lastBrush;
            RECT rt;
            GetClientRect(hwnd, &rt);
            BeginPaint(hwnd, &ps);
            rt.left = child->split_pos-SPLIT_WIDTH/2;
            rt.right = child->split_pos+SPLIT_WIDTH/2+1;
            lastBrush = SelectObject(ps.hdc, GetStockObject(COLOR_SPLITBAR));
            Rectangle(ps.hdc, rt.left, rt.top-1, rt.right, rt.bottom+1);
            SelectObject(ps.hdc, lastBrush);
            EndPaint(hwnd, &ps);
            break;}

        case WM_SETCURSOR:
            if (LOWORD(lparam) == HTCLIENT) {
                POINT pt;
                GetCursorPos(&pt);
                ScreenToClient(hwnd, &pt);

                if (pt.x>=child->split_pos-SPLIT_WIDTH/2 && pt.x<child->split_pos+SPLIT_WIDTH/2+1) {
                    SetCursor(LoadCursorW(0, (LPCWSTR)IDC_SIZEWE));
                    return TRUE;
                }
            }
            goto def;

        case WM_LBUTTONDOWN: {
            RECT rt;
                        int x = (short)LOWORD(lparam);

            GetClientRect(hwnd, &rt);

            if (x>=child->split_pos-SPLIT_WIDTH/2 && x<child->split_pos+SPLIT_WIDTH/2+1) {
                last_split = child->split_pos;
                SetCapture(hwnd);
            }

            break;}

        case WM_LBUTTONUP:
                        if (GetCapture() == hwnd)
                                ReleaseCapture();
            break;

        case WM_KEYDOWN:
            if (wparam == VK_ESCAPE)
                if (GetCapture() == hwnd) {
                    RECT rt;
                    child->split_pos = last_split;
                    GetClientRect(hwnd, &rt);
                    resize_tree(child, rt.right, rt.bottom);
                    last_split = -1;
                    ReleaseCapture();
                    SetCursor(LoadCursorW(0, (LPCWSTR)IDC_ARROW));
                }
            break;

        case WM_MOUSEMOVE:
            if (GetCapture() == hwnd) {
                RECT rt;
                                int x = (short)LOWORD(lparam);

                GetClientRect(hwnd, &rt);

                if (x>=0 && x<rt.right) {
                    child->split_pos = x;
                    resize_tree(child, rt.right, rt.bottom);
                    rt.left = x-SPLIT_WIDTH/2;
                    rt.right = x+SPLIT_WIDTH/2+1;
                    InvalidateRect(hwnd, &rt, FALSE);
                    UpdateWindow(child->left.hwnd);
                    UpdateWindow(hwnd);
                    UpdateWindow(child->right.hwnd);
                }
            }
            break;

        case WM_GETMINMAXINFO:
            DefMDIChildProcW(hwnd, nmsg, wparam, lparam);

            {LPMINMAXINFO lpmmi = (LPMINMAXINFO)lparam;

            lpmmi->ptMaxTrackSize.x <<= 1;/*2*GetSystemMetrics(SM_CXSCREEN) / SM_CXVIRTUALSCREEN */
            lpmmi->ptMaxTrackSize.y <<= 1;/*2*GetSystemMetrics(SM_CYSCREEN) / SM_CYVIRTUALSCREEN */
            break;}

        case WM_SETFOCUS:
            if (SetCurrentDirectoryW(child->path))
                set_space_status();
            SetFocus(child->focus_pane? child->right.hwnd: child->left.hwnd);
            break;

        case WM_DISPATCH_COMMAND: {
            Pane* pane = GetFocus()==child->left.hwnd? &child->left: &child->right;

            switch(LOWORD(wparam)) {
                case ID_WINDOW_NEW: {
                    ChildWnd* new_child = alloc_child_window(child->path, NULL, hwnd);

                    if (!create_child_window(new_child))
                        HeapFree(GetProcessHeap(), 0, new_child);

                    break;}

                case ID_REFRESH:
                    refresh_drives();
                    refresh_child(child);
                    break;

                case ID_ACTIVATE:
                    activate_entry(child, pane, hwnd);
                    break;

                case ID_FILE_MOVE: {
                    WCHAR source[BUFFER_LEN], target[BUFFER_LEN];

                    if (prompt_target(pane, source, target)) {
                        SHFILEOPSTRUCTW shfo = {hwnd, FO_MOVE, source, target};

                        source[lstrlenW(source)+1] = '\0';
                        target[lstrlenW(target)+1] = '\0';

                        if (!SHFileOperationW(&shfo))
                            refresh_child(child);
                    }
                    break;}

                case ID_FILE_COPY: {
                    WCHAR source[BUFFER_LEN], target[BUFFER_LEN];

                    if (prompt_target(pane, source, target)) {
                        SHFILEOPSTRUCTW shfo = {hwnd, FO_COPY, source, target};

                        source[lstrlenW(source)+1] = '\0';
                        target[lstrlenW(target)+1] = '\0';

                        if (!SHFileOperationW(&shfo))
                            refresh_child(child);
                    }
                    break;}

                case ID_FILE_DELETE: {
                    WCHAR path[BUFFER_LEN];
                    SHFILEOPSTRUCTW shfo = {hwnd, FO_DELETE, path, NULL, FOF_ALLOWUNDO};

                    get_path(pane->cur, path);

                    path[lstrlenW(path)+1] = '\0';

                    if (!SHFileOperationW(&shfo))
                        refresh_child(child);
                    break;}

                case ID_VIEW_SORT_NAME:
                    set_sort_order(child, SORT_NAME);
                    break;

                case ID_VIEW_SORT_TYPE:
                    set_sort_order(child, SORT_EXT);
                    break;

                case ID_VIEW_SORT_SIZE:
                    set_sort_order(child, SORT_SIZE);
                    break;

                case ID_VIEW_SORT_DATE:
                    set_sort_order(child, SORT_DATE);
                    break;

                case ID_VIEW_FILTER: {
                    struct FilterDialog dlg;

                    memset(&dlg, 0, sizeof(struct FilterDialog));
                    lstrcpyW(dlg.pattern, child->filter_pattern);
                    dlg.flags = child->filter_flags;

                    if (DialogBoxParamW(Globals.hInstance, MAKEINTRESOURCEW(IDD_DIALOG_VIEW_TYPE), hwnd, FilterDialogDlgProc, (LPARAM)&dlg) == IDOK) {
                        lstrcpyW(child->filter_pattern, dlg.pattern);
                        child->filter_flags = dlg.flags;
                        refresh_right_pane(child);
                    }
                    break;}

                case ID_VIEW_SPLIT: {
                    last_split = child->split_pos;
                    SetCapture(hwnd);
                    break;}

                case ID_EDIT_PROPERTIES:
                    show_properties_dlg(pane->cur, child->hwnd);
                    break;

                default:
                    return pane_command(pane, LOWORD(wparam));
            }

            return TRUE;}

        case WM_COMMAND: {
            Pane* pane = GetFocus()==child->left.hwnd? &child->left: &child->right;

            switch(HIWORD(wparam)) {
                case LBN_SELCHANGE: {
                    int idx = SendMessageW(pane->hwnd, LB_GETCURSEL, 0, 0);
                    Entry* entry = (Entry*)SendMessageW(pane->hwnd, LB_GETITEMDATA, idx, 0);

                    if (pane == &child->left)
                        set_curdir(child, entry, idx, hwnd);
                    else
                        pane->cur = entry;
                    break;}

                case LBN_DBLCLK:
                    activate_entry(child, pane, hwnd);
                    break;
            }
            break;}

        case WM_NOTIFY: {
            NMHDR* pnmh = (NMHDR*) lparam;
            return pane_notify(pnmh->idFrom==IDW_HEADER_LEFT? &child->left: &child->right, pnmh);}

        case WM_CONTEXTMENU: {
            POINT pt, pt_clnt;
            Pane* pane;
            int idx;

             /* first select the current item in the listbox */
            HWND hpanel = (HWND) wparam;
            pt_clnt.x = pt.x = (short)LOWORD(lparam);
            pt_clnt.y = pt.y = (short)HIWORD(lparam);
            ScreenToClient(hpanel, &pt_clnt);
            SendMessageW(hpanel, WM_LBUTTONDOWN, 0, MAKELONG(pt_clnt.x, pt_clnt.y));
            SendMessageW(hpanel, WM_LBUTTONUP, 0, MAKELONG(pt_clnt.x, pt_clnt.y));

             /* now create the popup menu using shell namespace and IContextMenu */
            pane = GetFocus()==child->left.hwnd? &child->left: &child->right;
            idx = SendMessageW(pane->hwnd, LB_GETCURSEL, 0, 0);

            if (idx != -1) {
                Entry* entry = (Entry*)SendMessageW(pane->hwnd, LB_GETITEMDATA, idx, 0);

                LPITEMIDLIST pidl_abs = get_to_absolute_pidl(entry, hwnd);

                if (pidl_abs) {
                    IShellFolder* parentFolder;
                    LPCITEMIDLIST pidlLast;

                     /* get and use the parent folder to display correct context menu in all cases */
                    if (SUCCEEDED(SHBindToParent(pidl_abs, &IID_IShellFolder, (LPVOID*)&parentFolder, &pidlLast))) {
                        if (ShellFolderContextMenu(parentFolder, hwnd, 1, &pidlLast, pt.x, pt.y) == S_OK)
                            refresh_child(child);

                        IShellFolder_Release(parentFolder);
                    }

                    IMalloc_Free(Globals.iMalloc, pidl_abs);
                }
            }
            break;}

          case WM_MEASUREITEM:
          draw_menu_item:
            if (!wparam)    /* Is the message menu-related? */
                if (CtxMenu_HandleMenuMsg(nmsg, wparam, lparam))
                    return TRUE;

            break;

          case WM_INITMENUPOPUP:
            if (CtxMenu_HandleMenuMsg(nmsg, wparam, lparam))
                return 0;

            update_view_menu(child);
            break;

          case WM_MENUCHAR: /* only supported by IContextMenu3 */
           if (s_pctxmenu3) {
               LRESULT lResult = 0;

               IContextMenu3_HandleMenuMsg2(s_pctxmenu3, nmsg, wparam, lparam, &lResult);

               return lResult;
           }

           break;

        case WM_SIZE:
            if (wparam != SIZE_MINIMIZED)
                resize_tree(child, LOWORD(lparam), HIWORD(lparam));
            /* fall through */

        default: def:
            return DefMDIChildProcW(hwnd, nmsg, wparam, lparam);
    }

    return 0;
}

static void choose_font ( HWND  hwnd )

inlinestatic

Definition at line 234 of file winefile.c.

Referenced by FrameWndProc().

{
        WCHAR dlg_name[BUFFER_LEN], dlg_info[BUFFER_LEN];
        CHOOSEFONTW chFont;
        LOGFONTW lFont;

        HDC hdc = GetDC(hwnd);

        GetObjectW(Globals.hfont, sizeof(LOGFONTW), &lFont);

        chFont.lStructSize = sizeof(CHOOSEFONTW);
        chFont.hwndOwner = hwnd;
        chFont.hDC = NULL;
        chFont.lpLogFont = &lFont;
        chFont.Flags = CF_SCREENFONTS | CF_FORCEFONTEXIST | CF_LIMITSIZE | CF_NOSCRIPTSEL | CF_INITTOLOGFONTSTRUCT | CF_NOVERTFONTS;
        chFont.rgbColors = RGB(0,0,0);
        chFont.lCustData = 0;
        chFont.lpfnHook = NULL;
        chFont.lpTemplateName = NULL;
        chFont.hInstance = Globals.hInstance;
        chFont.lpszStyle = NULL;
        chFont.nFontType = SIMULATED_FONTTYPE;
        chFont.nSizeMin = 0;
        chFont.nSizeMax = 24;

        if (ChooseFontW(&chFont)) {
                HWND childWnd;
                HFONT hFontOld;

                DeleteObject(Globals.hfont);
                Globals.hfont = CreateFontIndirectW(&lFont);
                hFontOld = SelectObject(hdc, Globals.hfont);
                GetTextExtentPoint32W(hdc, sSpace, 1, &Globals.spaceSize);

                /* change font in all open child windows */
                for(childWnd=GetWindow(Globals.hmdiclient,GW_CHILD); childWnd; childWnd=GetNextWindow(childWnd,GW_HWNDNEXT)) {
                        ChildWnd* child = (ChildWnd*) GetWindowLongPtrW(childWnd, GWLP_USERDATA);
                        SendMessageW(child->left.hwnd, WM_SETFONT, (WPARAM)Globals.hfont, TRUE);
                        SendMessageW(child->right.hwnd, WM_SETFONT, (WPARAM)Globals.hfont, TRUE);
                        SendMessageW(child->left.hwnd, LB_SETITEMHEIGHT, 1, max(Globals.spaceSize.cy,IMAGE_HEIGHT+3));
                        SendMessageW(child->right.hwnd, LB_SETITEMHEIGHT, 1, max(Globals.spaceSize.cy,IMAGE_HEIGHT+3));
                        InvalidateRect(child->left.hwnd, NULL, TRUE);
                        InvalidateRect(child->right.hwnd, NULL, TRUE);
                }

                SelectObject(hdc, hFontOld);
        }
        else if (CommDlgExtendedError()) {
                LoadStringW(Globals.hInstance, IDS_FONT_SEL_DLG_NAME, dlg_name, BUFFER_LEN);
                LoadStringW(Globals.hInstance, IDS_FONT_SEL_ERROR, dlg_info, BUFFER_LEN);
                MessageBoxW(hwnd, dlg_info, dlg_name, MB_OK);
        }

        ReleaseDC(hwnd, hdc);
}

static void collapse_entry ( Pane *  pane, Entry *  dir  )

static

Definition at line 3346 of file winefile.c.

Referenced by activate_entry().

{
        int idx;

        if (!dir) return;
        idx = SendMessageW(pane->hwnd, LB_FINDSTRING, 0, (LPARAM)dir);

    ShowWindow(pane->hwnd, SW_HIDE);

    /* hide sub entries */
    for(;;) {
        LRESULT res = SendMessageW(pane->hwnd, LB_GETITEMDATA, idx+1, 0);
        Entry* sub = (Entry*) res;

        if (res==LB_ERR || !sub || sub->level<=dir->level)
            break;

        SendMessageW(pane->hwnd, LB_DELETESTRING, idx+1, 0);
    }

    dir->expanded = FALSE;

    ShowWindow(pane->hwnd, SW_SHOW);
}

static int compareDate ( const void *  arg1, const void *  arg2  )

static

Definition at line 1102 of file winefile.c.

{
    const WIN32_FIND_DATAW* fd1 = &(*(const Entry* const*)arg1)->data;
    const WIN32_FIND_DATAW* fd2 = &(*(const Entry* const*)arg2)->data;

    int cmp = compareType(fd1, fd2);
    if (cmp)
        return cmp;

    return CompareFileTime(&fd2->ftLastWriteTime, &fd1->ftLastWriteTime);
}

static int compareExt ( const void *  arg1, const void *  arg2  )

static

Definition at line 1048 of file winefile.c.

{
    const WIN32_FIND_DATAW* fd1 = &(*(const Entry* const*)arg1)->data;
    const WIN32_FIND_DATAW* fd2 = &(*(const Entry* const*)arg2)->data;
    const WCHAR *name1, *name2, *ext1, *ext2;

    int cmp = compareType(fd1, fd2);
    if (cmp)
        return cmp;

    name1 = fd1->cFileName;
    name2 = fd2->cFileName;

    ext1 = strrchrW(name1, '.');
    ext2 = strrchrW(name2, '.');

    if (ext1)
        ext1++;
    else
        ext1 = sEmpty;

    if (ext2)
        ext2++;
    else
        ext2 = sEmpty;

    cmp = lstrcmpiW(ext1, ext2);
    if (cmp)
        return cmp;

    return lstrcmpiW(name1, name2);
}

static int compareName ( const void *  arg1, const void *  arg2  )

static

Definition at line 1036 of file winefile.c.

{
    const WIN32_FIND_DATAW* fd1 = &(*(const Entry* const*)arg1)->data;
    const WIN32_FIND_DATAW* fd2 = &(*(const Entry* const*)arg2)->data;

    int cmp = compareType(fd1, fd2);
    if (cmp)
        return cmp;

    return lstrcmpiW(fd1->cFileName, fd2->cFileName);
}

static int compareSize ( const void *  arg1, const void *  arg2  )

static

Definition at line 1081 of file winefile.c.

{
    const WIN32_FIND_DATAW* fd1 = &(*(const Entry* const*)arg1)->data;
    const WIN32_FIND_DATAW* fd2 = &(*(const Entry* const*)arg2)->data;

    int cmp = compareType(fd1, fd2);
    if (cmp)
        return cmp;

    cmp = fd2->nFileSizeHigh - fd1->nFileSizeHigh;

    if (cmp < 0)
        return -1;
    else if (cmp > 0)
        return 1;

    cmp = fd2->nFileSizeLow - fd1->nFileSizeLow;

    return cmp<0? -1: cmp>0? 1: 0;
}

static int compareType ( const WIN32_FIND_DATAW *  fd1, const WIN32_FIND_DATAW *  fd2  )

static

Definition at line 1021 of file winefile.c.

Referenced by compareDate(), compareExt(), compareName(), and compareSize().

{
    int order1 = fd1->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY? TO_DIR: TO_FILE;
    int order2 = fd2->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY? TO_DIR: TO_FILE;

    /* Handle "." and ".." as special case and move them at the very first beginning. */
    if (order1==TO_DIR && order2==TO_DIR) {
        order1 = TypeOrderFromDirname(fd1->cFileName);
        order2 = TypeOrderFromDirname(fd2->cFileName);
    }

    return order2==order1? 0: order1<order2? -1: 1;
}

static HWND create_child_window ( ChildWnd *  child )

static

Definition at line 1595 of file winefile.c.

Referenced by ChildWndProc(), FrameWndProc(), and show_frame().

{
    MDICREATESTRUCTW mcs;
    int idx;

    mcs.szClass = sWINEFILETREE;
    mcs.szTitle = child->path;
    mcs.hOwner  = Globals.hInstance;
    mcs.x       = child->pos.rcNormalPosition.left;
    mcs.y       = child->pos.rcNormalPosition.top;
    mcs.cx      = child->pos.rcNormalPosition.right-child->pos.rcNormalPosition.left;
    mcs.cy      = child->pos.rcNormalPosition.bottom-child->pos.rcNormalPosition.top;
    mcs.style   = 0;
    mcs.lParam  = 0;

    hcbthook = SetWindowsHookExW(WH_CBT, CBTProc, 0, GetCurrentThreadId());

    newchild = child;
    child->hwnd = (HWND)SendMessageW(Globals.hmdiclient, WM_MDICREATE, 0, (LPARAM)&mcs);
    if (!child->hwnd) {
        UnhookWindowsHookEx(hcbthook);
        return 0;
    }

    UnhookWindowsHookEx(hcbthook);

    SendMessageW(child->left.hwnd, LB_SETITEMHEIGHT, 1, max(Globals.spaceSize.cy,IMAGE_HEIGHT+3));
    SendMessageW(child->right.hwnd, LB_SETITEMHEIGHT, 1, max(Globals.spaceSize.cy,IMAGE_HEIGHT+3));

    idx = SendMessageW(child->left.hwnd, LB_FINDSTRING, 0, (LPARAM)child->left.cur);
    SendMessageW(child->left.hwnd, LB_SETCURSEL, idx, 0);

    return child->hwnd;
}

static void create_drive_bar ( void  )

static

Definition at line 3448 of file winefile.c.

Referenced by refresh_drives(), and show_frame().

{
    TBBUTTON drivebarBtn = {0, 0, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0};
    WCHAR b1[BUFFER_LEN];
    int btn = 1;
    PWSTR p;

    GetLogicalDriveStringsW(BUFFER_LEN, Globals.drives);

    Globals.hdrivebar = CreateToolbarEx(Globals.hMainWnd, WS_CHILD|WS_VISIBLE|CCS_NOMOVEY|TBSTYLE_LIST,
                IDW_DRIVEBAR, 2, Globals.hInstance, IDB_DRIVEBAR, &drivebarBtn,
                0, 16, 13, 16, 13, sizeof(TBBUTTON));

#ifdef __WINE__
    /* insert unix file system button */
    b1[0] = '/';
    b1[1] = '\0';
    b1[2] = '\0';
    SendMessageW(Globals.hdrivebar, TB_ADDSTRINGW, 0, (LPARAM)b1);

    drivebarBtn.idCommand = ID_DRIVE_UNIX_FS;
    SendMessageW(Globals.hdrivebar, TB_INSERTBUTTONW, btn++, (LPARAM)&drivebarBtn);
    drivebarBtn.iString++;
#endif
    /* insert shell namespace button */
    load_string(b1, sizeof(b1)/sizeof(b1[0]), IDS_SHELL);
    b1[lstrlenW(b1)+1] = '\0';
    SendMessageW(Globals.hdrivebar, TB_ADDSTRINGW, 0, (LPARAM)b1);

    drivebarBtn.idCommand = ID_DRIVE_SHELL_NS;
    SendMessageW(Globals.hdrivebar, TB_INSERTBUTTONW, btn++, (LPARAM)&drivebarBtn);
    drivebarBtn.iString++;

    /* register windows drive root strings */
    SendMessageW(Globals.hdrivebar, TB_ADDSTRINGW, 0, (LPARAM)Globals.drives);

    drivebarBtn.idCommand = ID_DRIVE_FIRST;

    for(p=Globals.drives; *p; ) {
        switch(GetDriveTypeW(p)) {
            case DRIVE_REMOVABLE:   drivebarBtn.iBitmap = 1;    break;
            case DRIVE_CDROM:       drivebarBtn.iBitmap = 3;    break;
            case DRIVE_REMOTE:      drivebarBtn.iBitmap = 4;    break;
            case DRIVE_RAMDISK:     drivebarBtn.iBitmap = 5;    break;
            default:/*DRIVE_FIXED*/ drivebarBtn.iBitmap = 2;
        }

        SendMessageW(Globals.hdrivebar, TB_INSERTBUTTONW, btn++, (LPARAM)&drivebarBtn);
        drivebarBtn.idCommand++;
        drivebarBtn.iString++;

        while(*p++);
    }
}

static HWND create_header ( HWND  parent, Pane *  pane, UINT  id  )

static

Definition at line 2339 of file winefile.c.

Referenced by create_tree_window().

{
    HDITEMW hdi;
    int idx;

    HWND hwnd = CreateWindowW(WC_HEADERW, 0, WS_CHILD|WS_VISIBLE|HDS_HORZ|HDS_FULLDRAG/*TODO: |HDS_BUTTONS + sort orders*/,
                                 0, 0, 0, 0, parent, (HMENU)ULongToHandle(id), Globals.hInstance, 0);
    if (!hwnd)
        return 0;

    SendMessageW(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), FALSE);

    hdi.mask = HDI_TEXT|HDI_WIDTH|HDI_FORMAT;

    for(idx=0; idx<COLUMNS; idx++) {
        hdi.pszText = g_pos_names[idx];
        hdi.fmt = HDF_STRING | g_pos_align[idx];
        hdi.cxy = pane->widths[idx];
        SendMessageW(hwnd, HDM_INSERTITEMW, idx, (LPARAM)&hdi);
    }

    return hwnd;
}

static void create_tree_window ( HWND  parent, Pane *  pane, UINT  id, UINT  id_header, LPCWSTR  pattern, int  filter_flags  )

static

Definition at line 2702 of file winefile.c.

Referenced by InitChildWindow().

{
    static const WCHAR sListBox[] = {'L','i','s','t','B','o','x','\0'};

        static BOOL s_init = FALSE;
    Entry* entry = pane->root;

    pane->hwnd = CreateWindowW(sListBox, sEmpty, WS_CHILD|WS_VISIBLE|WS_HSCROLL|WS_VSCROLL|
                                  LBS_DISABLENOSCROLL|LBS_NOINTEGRALHEIGHT|LBS_OWNERDRAWFIXED|LBS_NOTIFY,
                                  0, 0, 0, 0, parent, (HMENU)ULongToHandle(id), Globals.hInstance, 0);

    SetWindowLongPtrW(pane->hwnd, GWLP_USERDATA, (LPARAM)pane);
    g_orgTreeWndProc = (WNDPROC)SetWindowLongPtrW(pane->hwnd, GWLP_WNDPROC, (LPARAM)TreeWndProc);

    SendMessageW(pane->hwnd, WM_SETFONT, (WPARAM)Globals.hfont, FALSE);

    /* insert entries into listbox */
    if (entry)
        insert_entries(pane, entry, pattern, filter_flags, -1);

    /* calculate column widths */
    if (!s_init) {
                s_init = TRUE;
        init_output(pane->hwnd);
    }

    calc_widths(pane, TRUE);

    pane->hwndHeader = create_header(parent, pane, id_header);
}

static BOOL CtxMenu_HandleMenuMsg ( UINT  nmsg, WPARAM  wparam, LPARAM  lparam  )

static

Definition at line 3754 of file winefile.c.

Referenced by ChildWndProc().

{
    if (s_pctxmenu3) {
        if (SUCCEEDED(IContextMenu3_HandleMenuMsg(s_pctxmenu3, nmsg, wparam, lparam)))
            return TRUE;
    }

    if (s_pctxmenu2)
        if (SUCCEEDED(IContextMenu2_HandleMenuMsg(s_pctxmenu2, nmsg, wparam, lparam)))
            return TRUE;

    return FALSE;
}

static IContextMenu* CtxMenu_query_interfaces ( IContextMenu *  pcm1 )

static

Definition at line 3736 of file winefile.c.

Referenced by ShellFolderContextMenu().

{
    IContextMenu* pcm = NULL;

    CtxMenu_reset();

    if (IContextMenu_QueryInterface(pcm1, &IID_IContextMenu3, (void**)&pcm) == NOERROR)
        s_pctxmenu3 = (LPCONTEXTMENU3)pcm;
    else if (IContextMenu_QueryInterface(pcm1, &IID_IContextMenu2, (void**)&pcm) == NOERROR)
        s_pctxmenu2 = (LPCONTEXTMENU2)pcm;

    if (pcm) {
        IContextMenu_Release(pcm1);
        return pcm;
    } else
        return pcm1;
}

static void CtxMenu_reset ( void  )

static

Definition at line 3730 of file winefile.c.

Referenced by CtxMenu_query_interfaces(), and ShellFolderContextMenu().

{
    s_pctxmenu2 = NULL;
    s_pctxmenu3 = NULL;
}

static INT_PTR CALLBACK DestinationDlgProc ( HWND  hwnd, UINT  nmsg, WPARAM  wparam, LPARAM  lparam  )

static

Definition at line 1642 of file winefile.c.

Referenced by prompt_target().

{
    WCHAR b1[BUFFER_LEN], b2[BUFFER_LEN];

    switch(nmsg) {
        case WM_INITDIALOG:
            SetWindowLongPtrW(hwnd, GWLP_USERDATA, lparam);
            SetWindowTextW(GetDlgItem(hwnd, 201), (LPCWSTR)lparam);
            return 1;

        case WM_COMMAND: {
            int id = (int)wparam;

            switch(id) {
              case IDOK: {
                LPWSTR dest = (LPWSTR)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
                GetWindowTextW(GetDlgItem(hwnd, 201), dest, MAX_PATH);
                EndDialog(hwnd, id);
                break;}

              case IDCANCEL:
                EndDialog(hwnd, id);
                break;

              case 254:
                MessageBoxW(hwnd, RS(b1,IDS_NO_IMPL), RS(b2,IDS_WINEFILE), MB_OK);
                break;
            }

            return 1;
        }
    }

    return 0;
}

static void display_error ( HWND  hwnd, DWORD  error  )

static

Definition at line 199 of file winefile.c.

Referenced by FrameWndProc(), launch_entry(), and launch_file().

{
    WCHAR b1[BUFFER_LEN], b2[BUFFER_LEN];
    PWSTR msg;

    if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
        0, error, MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT), (PWSTR)&msg, 0, NULL))
        MessageBoxW(hwnd, msg, RS(b2,IDS_WINEFILE), MB_OK);
    else
        MessageBoxW(hwnd, RS(b1,IDS_ERROR), RS(b2,IDS_WINEFILE), MB_OK);

    LocalFree(msg);
}

static void display_network_error ( HWND  hwnd )

static

Definition at line 215 of file winefile.c.

Referenced by FrameWndProc().

{
    WCHAR msg[BUFFER_LEN], provider[BUFFER_LEN], b2[BUFFER_LEN];
    DWORD error;

    if (WNetGetLastErrorW(&error, msg, BUFFER_LEN, provider, BUFFER_LEN) == NO_ERROR)
        MessageBoxW(hwnd, msg, RS(b2,IDS_WINEFILE), MB_OK);
}

static void draw_item ( Pane *  pane, LPDRAWITEMSTRUCT  dis, Entry *  entry, int  calcWidthCol  )

static

Definition at line 2908 of file winefile.c.

Referenced by calc_single_width(), calc_widths(), and ChildWndProc().

{
    WCHAR buffer[BUFFER_LEN];
    DWORD attrs;
    int visible_cols = pane->visible_cols;
    COLORREF bkcolor, textcolor;
    RECT focusRect = dis->rcItem;
    HBRUSH hbrush;
    enum IMAGE img;
    int img_pos, cx;
    int col = 0;

    if (entry) {
        attrs = entry->data.dwFileAttributes;

        if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
            if (entry->data.cFileName[0] == '.' && entry->data.cFileName[1] == '.'
                    && entry->data.cFileName[2] == '\0')
                img = IMG_FOLDER_UP;
            else if (entry->data.cFileName[0] == '.' && entry->data.cFileName[1] == '\0')
                img = IMG_FOLDER_CUR;
                        else if (pane->treePane && (dis->itemState&ODS_FOCUS))
                img = IMG_OPEN_FOLDER;
            else
                img = IMG_FOLDER;
        } else {
            switch(get_file_type(entry->data.cFileName)) {
              case FT_EXECUTABLE:   img = IMG_EXECUTABLE;   break;
              case FT_DOCUMENT:     img = IMG_DOCUMENT;     break;
              default:              img = IMG_FILE;
            }
        }
    } else {
        attrs = 0;
        img = IMG_NONE;
    }

    if (pane->treePane) {
        if (entry) {
            img_pos = dis->rcItem.left + entry->level*(IMAGE_WIDTH+TREE_LINE_DX);

            if (calcWidthCol == -1) {
                int x;
                int y = dis->rcItem.top + IMAGE_HEIGHT/2;
                Entry* up;
                RECT rt_clip;
                HRGN hrgn_org = CreateRectRgn(0, 0, 0, 0);
                HRGN hrgn;

                rt_clip.left   = dis->rcItem.left;
                rt_clip.top    = dis->rcItem.top;
                rt_clip.right  = dis->rcItem.left+pane->widths[col];
                rt_clip.bottom = dis->rcItem.bottom;

                hrgn = CreateRectRgnIndirect(&rt_clip);

                if (!GetClipRgn(dis->hDC, hrgn_org)) {
                    DeleteObject(hrgn_org);
                    hrgn_org = 0;
                }

                ExtSelectClipRgn(dis->hDC, hrgn, RGN_AND);
                DeleteObject(hrgn);

                if ((up=entry->up) != NULL) {
                    MoveToEx(dis->hDC, img_pos-IMAGE_WIDTH/2, y, 0);
                    LineTo(dis->hDC, img_pos-2, y);

                    x = img_pos - IMAGE_WIDTH/2;

                    do {
                        x -= IMAGE_WIDTH+TREE_LINE_DX;

                        if (up->next
                            && (up->next->data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                            ) {
                            MoveToEx(dis->hDC, x, dis->rcItem.top, 0);
                            LineTo(dis->hDC, x, dis->rcItem.bottom);
                        }
                    } while((up=up->up) != NULL);
                }

                x = img_pos - IMAGE_WIDTH/2;

                MoveToEx(dis->hDC, x, dis->rcItem.top, 0);
                LineTo(dis->hDC, x, y);

                if (entry->next
                                        && (entry->next->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
                    LineTo(dis->hDC, x, dis->rcItem.bottom);

                SelectClipRgn(dis->hDC, hrgn_org);
                if (hrgn_org) DeleteObject(hrgn_org);
            } else if (calcWidthCol==col || calcWidthCol==COLUMNS) {
                int right = img_pos + IMAGE_WIDTH - TREE_LINE_DX;

                if (right > pane->widths[col])
                    pane->widths[col] = right;
            }
        } else  {
            img_pos = dis->rcItem.left;
        }
    } else {
        img_pos = dis->rcItem.left;

        if (calcWidthCol==col || calcWidthCol==COLUMNS)
            pane->widths[col] = IMAGE_WIDTH;
    }

    if (calcWidthCol == -1) {
        focusRect.left = img_pos -2;

        if (attrs & FILE_ATTRIBUTE_COMPRESSED)
            textcolor = COLOR_COMPRESSED;
        else
            textcolor = RGB(0,0,0);

        if (dis->itemState & ODS_FOCUS) {
            textcolor = RGB(255,255,255);
            bkcolor = COLOR_SELECTION;
        } else {
            bkcolor = RGB(255,255,255);
        }

        hbrush = CreateSolidBrush(bkcolor);
        FillRect(dis->hDC, &focusRect, hbrush);
        DeleteObject(hbrush);

        SetBkMode(dis->hDC, TRANSPARENT);
        SetTextColor(dis->hDC, textcolor);

        cx = pane->widths[col];

        if (cx && img!=IMG_NONE) {
            if (cx > IMAGE_WIDTH)
                cx = IMAGE_WIDTH;

            if (entry->hicon && entry->hicon!=(HICON)-1)
                DrawIconEx(dis->hDC, img_pos, dis->rcItem.top, entry->hicon, cx, GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
            else
                ImageList_DrawEx(Globals.himl, img, dis->hDC,
                                 img_pos, dis->rcItem.top, cx,
                                 IMAGE_HEIGHT, bkcolor, CLR_DEFAULT, ILD_NORMAL);
        }
    }

    if (!entry)
        return;

    col++;

    /* output file name */
    if (calcWidthCol == -1)
        output_text(pane, dis, col, entry->data.cFileName, 0);
    else if (calcWidthCol==col || calcWidthCol==COLUMNS)
        calc_width(pane, dis, col, entry->data.cFileName);

    col++;

        /* display file size */
    if (visible_cols & COL_SIZE) {
                format_longlong( buffer, ((ULONGLONG)entry->data.nFileSizeHigh << 32) | entry->data.nFileSizeLow );

                if (calcWidthCol == -1)
                        output_number(pane, dis, col, buffer);
                else if (calcWidthCol==col || calcWidthCol==COLUMNS)
                        calc_width(pane, dis, col, buffer);/*TODO: not ever time enough */

        col++;
    }

    /* display file date */
    if (visible_cols & (COL_DATE|COL_TIME)) {
        format_date(&entry->data.ftCreationTime, buffer, visible_cols);
        if (calcWidthCol == -1)
            output_text(pane, dis, col, buffer, 0);
        else if (calcWidthCol==col || calcWidthCol==COLUMNS)
            calc_width(pane, dis, col, buffer);
        col++;

        format_date(&entry->data.ftLastAccessTime, buffer, visible_cols);
        if (calcWidthCol == -1)
            output_text(pane, dis, col, buffer, 0);
        else if (calcWidthCol==col || calcWidthCol==COLUMNS)
            calc_width(pane, dis, col, buffer);
        col++;

        format_date(&entry->data.ftLastWriteTime, buffer, visible_cols);
        if (calcWidthCol == -1)
            output_text(pane, dis, col, buffer, 0);
        else if (calcWidthCol==col || calcWidthCol==COLUMNS)
            calc_width(pane, dis, col, buffer);
        col++;
    }

    if (entry->bhfi_valid) {
        if (visible_cols & COL_INDEX) {
                        static const WCHAR fmtlow[] = {'%','X',0};
                        static const WCHAR fmthigh[] = {'%','X','%','0','8','X',0};

                        if (entry->bhfi.nFileIndexHigh)
                            wsprintfW(buffer, fmthigh,
                                     entry->bhfi.nFileIndexHigh, entry->bhfi.nFileIndexLow );
                        else
                            wsprintfW(buffer, fmtlow, entry->bhfi.nFileIndexLow );

            if (calcWidthCol == -1)
                output_text(pane, dis, col, buffer, DT_RIGHT);
            else if (calcWidthCol==col || calcWidthCol==COLUMNS)
                calc_width(pane, dis, col, buffer);

            col++;
        }

        if (visible_cols & COL_LINKS) {
            wsprintfW(buffer, sNumFmt, entry->bhfi.nNumberOfLinks);

            if (calcWidthCol == -1)
                output_text(pane, dis, col, buffer, DT_CENTER);
            else if (calcWidthCol==col || calcWidthCol==COLUMNS)
                calc_width(pane, dis, col, buffer);

            col++;
        }
    } else
        col += 2;

    /* show file attributes */
    if (visible_cols & COL_ATTRIBUTES) {
        static const WCHAR s11Tabs[] = {' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\t',' ','\0'};
        lstrcpyW(buffer, s11Tabs);

        if (attrs & FILE_ATTRIBUTE_NORMAL)                  buffer[ 0] = 'N';
        else {
            if (attrs & FILE_ATTRIBUTE_READONLY)            buffer[ 2] = 'R';
            if (attrs & FILE_ATTRIBUTE_HIDDEN)              buffer[ 4] = 'H';
            if (attrs & FILE_ATTRIBUTE_SYSTEM)              buffer[ 6] = 'S';
            if (attrs & FILE_ATTRIBUTE_ARCHIVE)             buffer[ 8] = 'A';
            if (attrs & FILE_ATTRIBUTE_COMPRESSED)          buffer[10] = 'C';
            if (attrs & FILE_ATTRIBUTE_DIRECTORY)           buffer[12] = 'D';
            if (attrs & FILE_ATTRIBUTE_ENCRYPTED)           buffer[14] = 'E';
            if (attrs & FILE_ATTRIBUTE_TEMPORARY)           buffer[16] = 'T';
            if (attrs & FILE_ATTRIBUTE_SPARSE_FILE)         buffer[18] = 'P';
            if (attrs & FILE_ATTRIBUTE_REPARSE_POINT)       buffer[20] = 'Q';
            if (attrs & FILE_ATTRIBUTE_OFFLINE)             buffer[22] = 'O';
            if (attrs & FILE_ATTRIBUTE_NOT_CONTENT_INDEXED) buffer[24] = 'X';
        }

        if (calcWidthCol == -1)
            output_tabbed_text(pane, dis, col, buffer);
        else if (calcWidthCol==col || calcWidthCol==COLUMNS)
            calc_tabbed_width(pane, dis, col, buffer);

        col++;
    }
}

static void ExitInstance ( void  )

static

Definition at line 4379 of file winefile.c.

Referenced by wWinMain().

{
    IShellFolder_Release(Globals.iDesktop);
    IMalloc_Release(Globals.iMalloc);
    CoUninitialize();

    DeleteObject(Globals.hfont);
    ImageList_Destroy(Globals.himl);
}

static BOOL expand_entry ( ChildWnd *  child, Entry *  dir  )

static

Definition at line 3305 of file winefile.c.

Referenced by activate_entry().

{
    int idx;
    Entry* p;

    if (!dir || dir->expanded || !dir->down)
        return FALSE;

    p = dir->down;

    if (p->data.cFileName[0]=='.' && p->data.cFileName[1]=='\0' && p->next) {
        p = p->next;

        if (p->data.cFileName[0]=='.' && p->data.cFileName[1]=='.' &&
                p->data.cFileName[2]=='\0' && p->next)
            p = p->next;
    }

    /* no subdirectories ? */
    if (!(p->data.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY))
        return FALSE;

    idx = SendMessageW(child->left.hwnd, LB_FINDSTRING, 0, (LPARAM)dir);

    dir->expanded = TRUE;

    /* insert entries in left pane */
    insert_entries(&child->left, p, NULL, TF_ALL, idx);

    if (!child->header_wdths_ok) {
        if (calc_widths(&child->left, FALSE)) {
            set_header(&child->left);

            child->header_wdths_ok = TRUE;
        }
    }

    return TRUE;
}

static HICON extract_icon ( IShellFolder *  folder, LPCITEMIDLIST  pidl  )

static

Definition at line 737 of file winefile.c.

Referenced by read_directory_shell().

{
    IExtractIconW* pExtract;

    if (SUCCEEDED(IShellFolder_GetUIObjectOf(folder, 0, 1, (LPCITEMIDLIST*)&pidl, &IID_IExtractIconW, 0, (LPVOID*)&pExtract))) {
        WCHAR path[_MAX_PATH];
        unsigned flags;
        HICON hicon;
        int idx;

        if (SUCCEEDED(IExtractIconW_GetIconLocation(pExtract, GIL_FORSHELL, path, _MAX_PATH, &idx, &flags))) {
            if (!(flags & GIL_NOTFILENAME)) {
                if (idx == -1)
                    idx = 0;    /* special case for some control panel applications */

                if ((int)ExtractIconExW(path, idx, 0, &hicon, 1) > 0)
                    flags &= ~GIL_DONTCACHE;
            } else {
                HICON hIconLarge = 0;

                HRESULT hr = IExtractIconW_Extract(pExtract, path, idx, &hIconLarge, &hicon, MAKELONG(0/*GetSystemMetrics(SM_CXICON)*/,GetSystemMetrics(SM_CXSMICON)));

                if (SUCCEEDED(hr))
                    DestroyIcon(hIconLarge);
            }

            return hicon;
        }
    }

    return 0;
}

static void fill_w32fdata_shell ( IShellFolder *  folder, LPCITEMIDLIST  pidl, SFGAOF  attribs, WIN32_FIND_DATAW *  w32fdata  )

static

Definition at line 836 of file winefile.c.

Referenced by read_directory_shell().

{
    if (!(attribs & SFGAO_FILESYSTEM) ||
            FAILED(SHGetDataFromIDListW(folder, pidl, SHGDFIL_FINDDATA, w32fdata, sizeof(WIN32_FIND_DATAW)))) {
        WIN32_FILE_ATTRIBUTE_DATA fad;
        IDataObject* pDataObj;

        STGMEDIUM medium = {0, {0}, 0};
        FORMATETC fmt = {Globals.cfStrFName, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};

        HRESULT hr = IShellFolder_GetUIObjectOf(folder, 0, 1, &pidl, &IID_IDataObject, 0, (LPVOID*)&pDataObj);

        if (SUCCEEDED(hr)) {
            hr = IDataObject_GetData(pDataObj, &fmt, &medium);

            IDataObject_Release(pDataObj);

            if (SUCCEEDED(hr)) {
                LPCWSTR path = GlobalLock(medium.UNION_MEMBER(hGlobal));
                UINT sem_org = SetErrorMode(SEM_FAILCRITICALERRORS);

                if (GetFileAttributesExW(path, GetFileExInfoStandard, &fad)) {
                    w32fdata->dwFileAttributes = fad.dwFileAttributes;
                    w32fdata->ftCreationTime = fad.ftCreationTime;
                    w32fdata->ftLastAccessTime = fad.ftLastAccessTime;
                    w32fdata->ftLastWriteTime = fad.ftLastWriteTime;

                    if (!(fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
                        w32fdata->nFileSizeLow = fad.nFileSizeLow;
                        w32fdata->nFileSizeHigh = fad.nFileSizeHigh;
                    }
                }

                SetErrorMode(sem_org);

                GlobalUnlock(medium.UNION_MEMBER(hGlobal));
                GlobalFree(medium.UNION_MEMBER(hGlobal));
            }
        }
    }

    if (attribs & (SFGAO_FOLDER|SFGAO_HASSUBFOLDER))
        w32fdata->dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;

    if (attribs & SFGAO_READONLY)
        w32fdata->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;

    if (attribs & SFGAO_COMPRESSED)
        w32fdata->dwFileAttributes |= FILE_ATTRIBUTE_COMPRESSED;
}

static INT_PTR CALLBACK FilterDialogDlgProc ( HWND  hwnd, UINT  nmsg, WPARAM  wparam, LPARAM  lparam  )

static

Definition at line 1684 of file winefile.c.

Referenced by ChildWndProc().

{
    static struct FilterDialog* dlg;

    switch(nmsg) {
        case WM_INITDIALOG:
            dlg = (struct FilterDialog*) lparam;
            SetWindowTextW(GetDlgItem(hwnd, IDC_VIEW_PATTERN), dlg->pattern);
            set_check(hwnd, IDC_VIEW_TYPE_DIRECTORIES, dlg->flags&TF_DIRECTORIES);
            set_check(hwnd, IDC_VIEW_TYPE_PROGRAMS, dlg->flags&TF_PROGRAMS);
            set_check(hwnd, IDC_VIEW_TYPE_DOCUMENTS, dlg->flags&TF_DOCUMENTS);
            set_check(hwnd, IDC_VIEW_TYPE_OTHERS, dlg->flags&TF_OTHERS);
            set_check(hwnd, IDC_VIEW_TYPE_HIDDEN, dlg->flags&TF_HIDDEN);
            return 1;

        case WM_COMMAND: {
            int id = (int)wparam;

            if (id == IDOK) {
                int flags = 0;

                GetWindowTextW(GetDlgItem(hwnd, IDC_VIEW_PATTERN), dlg->pattern, MAX_PATH);

                flags |= get_check(hwnd, IDC_VIEW_TYPE_DIRECTORIES) ? TF_DIRECTORIES : 0;
                flags |= get_check(hwnd, IDC_VIEW_TYPE_PROGRAMS) ? TF_PROGRAMS : 0;
                flags |= get_check(hwnd, IDC_VIEW_TYPE_DOCUMENTS) ? TF_DOCUMENTS : 0;
                flags |= get_check(hwnd, IDC_VIEW_TYPE_OTHERS) ? TF_OTHERS : 0;
                flags |= get_check(hwnd, IDC_VIEW_TYPE_HIDDEN) ? TF_HIDDEN : 0;

                dlg->flags = flags;

                EndDialog(hwnd, id);
            } else if (id == IDCANCEL)
                EndDialog(hwnd, id);

            return 1;}
    }

    return 0;
}

static Entry* find_entry_shell ( Entry *  dir, LPCITEMIDLIST  pidl  )

static

Definition at line 771 of file winefile.c.

Referenced by read_tree_shell().

{
    Entry* entry;

    for(entry=dir->down; entry; entry=entry->next) {
        if (entry->pidl->mkid.cb == pidl->mkid.cb &&
            !memcmp(entry->pidl, pidl, entry->pidl->mkid.cb))
            return entry;
    }

    return 0;
}

static Entry* find_entry_win ( Entry *  dir, LPCWSTR  name  )

static

Definition at line 403 of file winefile.c.

Referenced by read_tree_win().

{
    Entry* entry;

    for(entry=dir->down; entry; entry=entry->next) {
        LPCWSTR p = name;
        LPCWSTR q = entry->data.cFileName;

        do {
            if (!*p || *p == '\\' || *p == '/')
                return entry;
        } while(tolower(*p++) == tolower(*q++));

        p = name;
        q = entry->data.cAlternateFileName;

        do {
            if (!*p || *p == '\\' || *p == '/')
                return entry;
        } while(tolower(*p++) == tolower(*q++));
    }

    return 0;
}

static void format_bytes ( LPWSTR  buffer, LONGLONG  bytes  )

static

Definition at line 2647 of file winefile.c.

Referenced by set_space_status().

{
    static const WCHAR sFmtSmall[]  = {'%', 'u', 0};
    static const WCHAR sFmtBig[] = {'%', '.', '1', 'f', ' ', '%', 's', '\0'};

    if (bytes < 1024)
        sprintfW(buffer, sFmtSmall, (DWORD)bytes);
    else
    {
        WCHAR unit[64];
        UINT resid;
        float fBytes;
        if (bytes >= 1073741824)    /* 1 GB */
        {
            fBytes = ((float)bytes)/1073741824.f+.5f;
            resid = IDS_UNIT_GB;
        }
        else if (bytes >= 1048576)  /* 1 MB */
        {
            fBytes = ((float)bytes)/1048576.f+.5f;
            resid = IDS_UNIT_MB;
        }
        else /* bytes >= 1024 */    /* 1 kB */
        {
            fBytes = ((float)bytes)/1024.f+.5f;
            resid = IDS_UNIT_KB;
        }
        LoadStringW(Globals.hInstance, resid, unit, sizeof(unit)/sizeof(*unit));
        sprintfW(buffer, sFmtBig, fBytes, unit);
    }
}

static void format_date ( const FILETIME *  ft, WCHAR *  buffer, int  visible_cols  )

static

Definition at line 2741 of file winefile.c.

Referenced by draw_item(), and PropertiesDialogDlgProc().

{
    SYSTEMTIME systime;
    FILETIME lft;
    int len = 0;

    *buffer = '\0';

    if (!ft->dwLowDateTime && !ft->dwHighDateTime)
        return;

    if (!FileTimeToLocalFileTime(ft, &lft))
        {err: lstrcpyW(buffer,sQMarks); return;}

    if (!FileTimeToSystemTime(&lft, &systime))
        goto err;

    if (visible_cols & COL_DATE) {
        len = GetDateFormatW(LOCALE_USER_DEFAULT, 0, &systime, 0, buffer, BUFFER_LEN);
        if (!len)
            goto err;
    }

    if (visible_cols & COL_TIME) {
        if (len)
            buffer[len-1] = ' ';

        buffer[len++] = ' ';

        if (!GetTimeFormatW(LOCALE_USER_DEFAULT, 0, &systime, 0, buffer+len, BUFFER_LEN-len))
            buffer[len] = '\0';
    }
}