ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/commdlg/filedlg95.c

2461 lines
72 KiB
C
Raw Blame History

/*
* COMMDLG - File Open Dialogs Win95 look and feel
*
*/
#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "winbase.h"
#include "ldt.h"
#include "heap.h"
#include "commdlg.h"
#include "dlgs.h"
#include "cdlg.h"
#include "debugtools.h"
#include "cderr.h"
#include "tweak.h"
#include "winnls.h"
#include "shellapi.h"
#include "tchar.h"
#include "filedlgbrowser.h"
#include "wine/obj_contextmenu.h"
DEFAULT_DEBUG_CHANNEL(commdlg);
/***********************************************************************
* Data structure and global variables
*/
typedef struct SFolder
{
int m_iImageIndex; /* Index of picture in image list */
HIMAGELIST hImgList;
int m_iIndent; /* Indentation index */
LPITEMIDLIST pidlItem; /* absolute pidl of the item */
} SFOLDER,*LPSFOLDER;
typedef struct tagLookInInfo
{
int iMaxIndentation;
UINT uSelectedItem;
} LookInInfos;
/***********************************************************************
* Defines and global variables
*/
/* Draw item constant */
#define ICONWIDTH 18
#define YTEXTOFFSET 2
#define XTEXTOFFSET 3
/* AddItem flags*/
#define LISTEND -1
/* SearchItem methods */
#define SEARCH_PIDL 1
#define SEARCH_EXP 2
#define ITEM_NOTFOUND -1
/* Undefined windows message sent by CreateViewObject*/
#define WM_GETISHELLBROWSER WM_USER+7
/* NOTE
* Those macros exist in windowsx.h. However, you can't really use them since
* they rely on the UNICODE defines and can't be use inside Wine itself.
*/
/* Combo box macros */
#define CBAddString(hwnd,str) \
SendMessageA(hwnd,CB_ADDSTRING,0,(LPARAM)str);
#define CBInsertString(hwnd,str,pos) \
SendMessageA(hwnd,CB_INSERTSTRING,(WPARAM)pos,(LPARAM)str);
#define CBDeleteString(hwnd,pos) \
SendMessageA(hwnd,CB_DELETESTRING,(WPARAM)pos,0);
#define CBSetItemDataPtr(hwnd,iItemId,dataPtr) \
SendMessageA(hwnd,CB_SETITEMDATA,(WPARAM)iItemId,(LPARAM)dataPtr);
#define CBGetItemDataPtr(hwnd,iItemId) \
SendMessageA(hwnd,CB_GETITEMDATA,(WPARAM)iItemId,0)
#define CBGetLBText(hwnd,iItemId,str) \
SendMessageA(hwnd,CB_GETLBTEXT,(WPARAM)iItemId,(LPARAM)str);
#define CBGetCurSel(hwnd) \
SendMessageA(hwnd,CB_GETCURSEL,0,0);
#define CBSetCurSel(hwnd,pos) \
SendMessageA(hwnd,CB_SETCURSEL,(WPARAM)pos,0);
#define CBGetCount(hwnd) \
SendMessageA(hwnd,CB_GETCOUNT,0,0);
#define CBShowDropDown(hwnd,show) \
SendMessageA(hwnd,CB_SHOWDROPDOWN,(WPARAM)show,0);
#define CBSetItemHeight(hwnd,index,height) \
SendMessageA(hwnd,CB_SETITEMHEIGHT,(WPARAM)index,(LPARAM)height);
const char *FileOpenDlgInfosStr = "FileOpenDlgInfos"; /* windows property description string */
const char *LookInInfosStr = "LookInInfos"; /* LOOKIN combo box property */
static const char defaultFilter[] = "*.*";
/***********************************************************************
* Prototypes
*/
/* Internal functions used by the dialog */
static LRESULT FILEDLG95_OnWMInitDialog(HWND hwnd, WPARAM wParam, LPARAM lParam);
static LRESULT FILEDLG95_OnWMCommand(HWND hwnd, WPARAM wParam, LPARAM lParam);
static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd);
BOOL FILEDLG95_OnOpen(HWND hwnd);
static LRESULT FILEDLG95_InitUI(HWND hwnd);
static void FILEDLG95_Clean(HWND hwnd);
/* Functions used by the shell object */
static LRESULT FILEDLG95_SHELL_Init(HWND hwnd);
static BOOL FILEDLG95_SHELL_UpFolder(HWND hwnd);
static BOOL FILEDLG95_SHELL_ExecuteCommand(HWND hwnd, LPCSTR lpVerb);
static void FILEDLG95_SHELL_Clean(HWND hwnd);
/* Functions used by the filetype combo box */
static HRESULT FILEDLG95_FILETYPE_Init(HWND hwnd);
static BOOL FILEDLG95_FILETYPE_OnCommand(HWND hwnd, WORD wNotifyCode);
static int FILEDLG95_FILETYPE_SearchExt(HWND hwnd,LPSTR lpstrExt);
static void FILEDLG95_FILETYPE_Clean(HWND hwnd);
/* Functions used by the Look In combo box */
static HRESULT FILEDLG95_LOOKIN_Init(HWND hwndCombo);
static LRESULT FILEDLG95_LOOKIN_DrawItem(LPDRAWITEMSTRUCT pDIStruct);
static BOOL FILEDLG95_LOOKIN_OnCommand(HWND hwnd, WORD wNotifyCode);
static int FILEDLG95_LOOKIN_AddItem(HWND hwnd,LPITEMIDLIST pidl, int iInsertId);
static int FILEDLG95_LOOKIN_SearchItem(HWND hwnd,WPARAM searchArg,int iSearchMethod);
static int FILEDLG95_LOOKIN_InsertItemAfterParent(HWND hwnd,LPITEMIDLIST pidl);
static int FILEDLG95_LOOKIN_RemoveMostExpandedItem(HWND hwnd);
int FILEDLG95_LOOKIN_SelectItem(HWND hwnd,LPITEMIDLIST pidl);
static void FILEDLG95_LOOKIN_Clean(HWND hwnd);
/* Miscellaneous tool functions */
HRESULT GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl,DWORD dwFlags,LPSTR lpstrFileName);
HRESULT GetFileName(HWND hwnd, LPITEMIDLIST pidl, LPSTR lpstrFileName);
IShellFolder* GetShellFolderFromPidl(LPITEMIDLIST pidlAbs);
LPITEMIDLIST GetParentPidl(LPITEMIDLIST pidl);
LPITEMIDLIST GetPidlFromName(IShellFolder *psf,LPCSTR lpcstrFileName);
/* Shell memory allocation */
void *MemAlloc(UINT size);
void MemFree(void *mem);
BOOL WINAPI GetFileName95(FileOpenDlgInfos *fodInfos);
HRESULT WINAPI FileOpenDlgProc95(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
HRESULT SendCustomDlgNotificationMessage(HWND hwndParentDlg, UINT uCode);
HRESULT FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
BOOL FILEDLG95_OnOpenMultipleFiles(HWND hwnd, LPSTR lpstrFileList, UINT nFileCount, UINT sizeUsed);
/***********************************************************************
* GetFileName95
*
* Creates an Open common dialog box that lets the user select
* the drive, directory, and the name of a file or set of files to open.
*
* IN : The FileOpenDlgInfos structure associated with the dialog
* OUT : TRUE on success
* FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
*/
BOOL WINAPI GetFileName95(FileOpenDlgInfos *fodInfos)
{
LRESULT lRes;
LPCVOID template;
HRSRC hRes;
HANDLE hDlgTmpl = 0;
/* Create the dialog from a template */
if(!(hRes = FindResourceA(COMMDLG_hInstance32,MAKEINTRESOURCEA(NEWFILEOPENORD),RT_DIALOGA)))
{
COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
return FALSE;
}
if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hRes )) ||
!(template = LockResource( hDlgTmpl )))
{
COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
return FALSE;
}
lRes = DialogBoxIndirectParamA(COMMDLG_hInstance32,
(LPDLGTEMPLATEA) template,
fodInfos->ofnInfos->hwndOwner,
(DLGPROC) FileOpenDlgProc95,
(LPARAM) fodInfos);
/* Unable to create the dialog*/
if( lRes == -1)
return FALSE;
return lRes;
}
/***********************************************************************
* GetFileDialog95A
*
* Copy the OPENFILENAMEA structure in a FileOpenDlgInfos structure.
* Call GetFileName95 with this structure and clean the memory.
*
* IN : The OPENFILENAMEA initialisation structure passed to
* GetOpenFileNameA win api function (see filedlg.c)
*/
BOOL WINAPI GetFileDialog95A(LPOPENFILENAMEA ofn,UINT iDlgType)
{
BOOL ret;
FileOpenDlgInfos *fodInfos;
HINSTANCE hInstance;
LPCSTR lpstrFilter = NULL;
LPSTR lpstrCustomFilter = NULL;
LPCSTR lpstrInitialDir = NULL;
DWORD dwFlags = 0;
/* Initialise FileOpenDlgInfos structure*/
fodInfos = (FileOpenDlgInfos*)MemAlloc(sizeof(FileOpenDlgInfos));
/* Pass in the original ofn */
fodInfos->ofnInfos = ofn;
/* Save original hInstance value */
hInstance = ofn->hInstance;
fodInfos->ofnInfos->hInstance = MapHModuleLS(ofn->hInstance);
if (ofn->lpstrFilter)
{
LPSTR s,x;
lpstrFilter = ofn->lpstrFilter;
/* filter is a list... title\0ext\0......\0\0 */
s = (LPSTR)ofn->lpstrFilter;
while (*s)
s = s+strlen(s)+1;
s++;
x = (LPSTR)MemAlloc(s-ofn->lpstrFilter);
memcpy(x,ofn->lpstrFilter,s-ofn->lpstrFilter);
fodInfos->ofnInfos->lpstrFilter = (LPSTR)x;
}
if (ofn->lpstrCustomFilter)
{
LPSTR s,x;
lpstrCustomFilter = ofn->lpstrCustomFilter;
/* filter is a list... title\0ext\0......\0\0 */
s = (LPSTR)ofn->lpstrCustomFilter;
while (*s)
s = s+strlen(s)+1;
s++;
x = MemAlloc(s-ofn->lpstrCustomFilter);
memcpy(x,ofn->lpstrCustomFilter,s-ofn->lpstrCustomFilter);
fodInfos->ofnInfos->lpstrCustomFilter = (LPSTR)x;
}
dwFlags = ofn->Flags;
fodInfos->ofnInfos->Flags = ofn->Flags|OFN_WINE;
/* Replace the NULL lpstrInitialDir by the current folder */
lpstrInitialDir = ofn->lpstrInitialDir;
if(!lpstrInitialDir)
{
fodInfos->ofnInfos->lpstrInitialDir = MemAlloc(MAX_PATH);
GetCurrentDirectoryA(MAX_PATH,(LPSTR)fodInfos->ofnInfos->lpstrInitialDir);
}
/* Initialise the dialog property */
fodInfos->DlgInfos.dwDlgProp = 0;
fodInfos->DlgInfos.hwndCustomDlg = (HWND)NULL;
switch(iDlgType)
{
case OPEN_DIALOG :
ret = GetFileName95(fodInfos);
break;
case SAVE_DIALOG :
fodInfos->DlgInfos.dwDlgProp |= FODPROP_SAVEDLG;
ret = GetFileName95(fodInfos);
break;
default :
ret = 0;
}
if (lpstrInitialDir)
{
MemFree((LPVOID)(fodInfos->ofnInfos->lpstrInitialDir));
fodInfos->ofnInfos->lpstrInitialDir = lpstrInitialDir;
}
if (lpstrFilter)
{
MemFree((LPVOID)(fodInfos->ofnInfos->lpstrFilter));
fodInfos->ofnInfos->lpstrFilter = lpstrFilter;
}
if (lpstrCustomFilter)
{
MemFree((LPVOID)(fodInfos->ofnInfos->lpstrCustomFilter));
fodInfos->ofnInfos->lpstrCustomFilter = lpstrCustomFilter;
}
ofn->Flags = dwFlags;
ofn->hInstance = hInstance;
MemFree((LPVOID)(fodInfos));
return ret;
}
/***********************************************************************
* GetFileDialog95W
*
* Copy the OPENFILENAMEW structure in a FileOpenDlgInfos structure.
* Call GetFileName95 with this structure and clean the memory.
*
* IN : The OPENFILENAMEW initialisation structure passed to
* GetOpenFileNameW win api function (see filedlg.c)
*
* FIXME:
* some more strings are needing to be convertet AtoW
*/
BOOL WINAPI GetFileDialog95W(LPOPENFILENAMEW ofn,UINT iDlgType)
{
BOOL ret;
FileOpenDlgInfos *fodInfos;
HINSTANCE hInstance;
LPCSTR lpstrFilter = NULL;
LPSTR lpstrCustomFilter = NULL;
LPWSTR lpstrFile = NULL;
DWORD dwFlags;
/* Initialise FileOpenDlgInfos structure*/
fodInfos = (FileOpenDlgInfos*)MemAlloc(sizeof(FileOpenDlgInfos));
/* Pass in the original ofn */
fodInfos->ofnInfos = (LPOPENFILENAMEA) ofn;
/* Save hInstance */
hInstance = fodInfos->ofnInfos->hInstance;
fodInfos->ofnInfos->hInstance = MapHModuleLS(ofn->hInstance);
/* Save lpstrFilter */
if (ofn->lpstrFilter)
{
LPWSTR s;
LPSTR x,y;
int n;
lpstrFilter = fodInfos->ofnInfos->lpstrFilter;
/* filter is a list... title\0ext\0......\0\0 */
s = (LPWSTR)ofn->lpstrFilter;
while (*s)
s = s+lstrlenW(s)+1;
s++;
n = s - ofn->lpstrFilter; /* already divides by 2. ptr magic */
x = y = (LPSTR)MemAlloc(n);
s = (LPWSTR)ofn->lpstrFilter;
while (*s) {
lstrcpyWtoA(x,s);
x+=lstrlenA(x)+1;
s+=lstrlenW(s)+1;
}
*x=0;
fodInfos->ofnInfos->lpstrFilter = (LPSTR)y;
}
/* Save lpstrCustomFilter */
if (ofn->lpstrCustomFilter)
{
LPWSTR s;
LPSTR x,y;
int n;
lpstrCustomFilter = fodInfos->ofnInfos->lpstrCustomFilter;
/* filter is a list... title\0ext\0......\0\0 */
s = (LPWSTR)ofn->lpstrCustomFilter;
while (*s)
s = s+lstrlenW(s)+1;
s++;
n = s - ofn->lpstrCustomFilter;
x = y = (LPSTR)MemAlloc(n);
s = (LPWSTR)ofn->lpstrCustomFilter;
while (*s) {
lstrcpyWtoA(x,s);
x+=lstrlenA(x)+1;
s+=lstrlenW(s)+1;
}
*x=0;
fodInfos->ofnInfos->lpstrCustomFilter = (LPSTR)y;
}
/* Save Flags */
dwFlags = fodInfos->ofnInfos->Flags;
fodInfos->ofnInfos->Flags = ofn->Flags|OFN_WINE|OFN_UNICODE;
/* Initialise the dialog property */
fodInfos->DlgInfos.dwDlgProp = 0;
/* allocate ansi filename buffer */
lpstrFile = ofn->lpstrFile;
ofn->lpstrFile = MemAlloc(ofn->nMaxFile);
switch(iDlgType)
{
case OPEN_DIALOG :
ret = GetFileName95(fodInfos);
break;
case SAVE_DIALOG :
fodInfos->DlgInfos.dwDlgProp |= FODPROP_SAVEDLG;
ret = GetFileName95(fodInfos);
break;
default :
ret = 0;
}
/* Cleaning */
/* Restore Flags */
fodInfos->ofnInfos->Flags = dwFlags;
/* Restore lpstrFilter */
if (fodInfos->ofnInfos->lpstrFilter)
{
MemFree((LPVOID)(fodInfos->ofnInfos->lpstrFilter));
fodInfos->ofnInfos->lpstrFilter = lpstrFilter;
}
if (fodInfos->ofnInfos->lpstrCustomFilter)
{
MemFree((LPVOID)(fodInfos->ofnInfos->lpstrCustomFilter));
fodInfos->ofnInfos->lpstrCustomFilter = lpstrCustomFilter;
}
/* Restore hInstance */
fodInfos->ofnInfos->hInstance = hInstance;
MemFree((LPVOID)(fodInfos));
/* filename */
lstrcpynAtoW(lpstrFile, (LPCSTR)ofn->lpstrFile, ofn->nMaxFile);
MemFree(ofn->lpstrFile);
ofn->lpstrFile = lpstrFile;
return ret;
}
void ArrangeCtrlPositions( HWND hwndChildDlg, HWND hwndParentDlg)
{
HWND hwndChild,hwndStc32;
RECT rectParent, rectChild, rectCtrl, rectStc32, rectTemp;
POINT ptMoveCtl;
POINT ptParentClient;
ptMoveCtl.x = ptMoveCtl.y = 0;
hwndStc32=GetDlgItem(hwndChildDlg,stc32);
GetClientRect(hwndParentDlg,&rectParent);
GetClientRect(hwndChildDlg,&rectChild);
if(hwndStc32)
{
GetWindowRect(hwndStc32,&rectStc32);
MapWindowPoints(0, hwndChildDlg,(LPPOINT)&rectStc32,2);
CopyRect(&rectTemp,&rectStc32);
SetRect(&rectStc32,rectStc32.left,rectStc32.top,rectStc32.left + (rectParent.right-rectParent.left),rectStc32.top+(rectParent.bottom-rectParent.top));
SetWindowPos(hwndStc32,0,rectStc32.left,rectStc32.top,rectStc32.right-rectStc32.left,rectStc32.bottom-rectStc32.top,SWP_NOMOVE|SWP_NOZORDER | SWP_NOACTIVATE);
if(rectStc32.right < rectTemp.right)
{
ptParentClient.x = max((rectParent.right-rectParent.left),(rectChild.right-rectChild.left));
ptMoveCtl.x = 0;
}
else
{
ptMoveCtl.x = (rectStc32.right - rectTemp.right);
ptParentClient.x = max((rectParent.right-rectParent.left),((rectChild.right-rectChild.left)+rectStc32.right-rectTemp.right));
}
if(rectStc32.bottom < rectTemp.bottom)
{
ptParentClient.y = max((rectParent.bottom-rectParent.top),(rectChild.bottom-rectChild.top));
ptMoveCtl.y = 0;
}
else
{
ptMoveCtl.y = (rectStc32.bottom - rectTemp.bottom);
ptParentClient.y = max((rectParent.bottom-rectParent.top),((rectChild.bottom-rectChild.top)+rectStc32.bottom-rectTemp.bottom));
}
}
else
{
if( (GetWindow(hwndChildDlg,GW_CHILD)) == (HWND) NULL)
return;
SetRectEmpty(&rectTemp);
ptParentClient.x = max((rectParent.right-rectParent.left),(rectChild.right-rectChild.left));
ptParentClient.y = (rectParent.bottom-rectParent.top) + (rectChild.bottom-rectChild.top);
ptMoveCtl.y = rectParent.bottom-rectParent.top;
ptMoveCtl.x=0;
}
SetRect(&rectParent,rectParent.left,rectParent.top,rectParent.left+ptParentClient.x,rectParent.top+ptParentClient.y);
AdjustWindowRectEx( &rectParent,GetWindowLongA(hwndParentDlg,GWL_STYLE),FALSE,GetWindowLongA(hwndParentDlg,GWL_EXSTYLE));
SetWindowPos(hwndChildDlg, 0, 0,0, ptParentClient.x,ptParentClient.y,
SWP_NOZORDER );
SetWindowPos(hwndParentDlg, 0, rectParent.left,rectParent.top, (rectParent.right- rectParent.left),
(rectParent.bottom-rectParent.top),SWP_NOMOVE | SWP_NOZORDER);
hwndChild = GetWindow(hwndChildDlg,GW_CHILD);
if(hwndStc32)
{
GetWindowRect(hwndStc32,&rectStc32);
MapWindowPoints( 0, hwndChildDlg,(LPPOINT)&rectStc32,2);
}
else
SetRect(&rectStc32,0,0,0,0);
if (hwndChild )
{
do
{
if(hwndChild != hwndStc32)
{
if (GetWindowLongA( hwndChild, GWL_STYLE ) & WS_MAXIMIZE)
continue;
GetWindowRect(hwndChild,&rectCtrl);
MapWindowPoints( 0, hwndParentDlg,(LPPOINT)&rectCtrl,2);
/*
Check the initial position of the controls relative to the initial
position and size of stc32 (before it is expanded).
*/
if (rectCtrl.left >= rectTemp.right && rectCtrl.top >= rectTemp.bottom)
{
rectCtrl.left += ptMoveCtl.x;
rectCtrl.top += ptMoveCtl.y;
}
else if (rectCtrl.left >= rectTemp.right)
rectCtrl.left += ptMoveCtl.x;
else if (rectCtrl.top >= rectTemp.bottom)
rectCtrl.top += ptMoveCtl.y;
SetWindowPos( hwndChild, 0, rectCtrl.left, rectCtrl.top,
rectCtrl.right-rectCtrl.left,rectCtrl.bottom-rectCtrl.top,
SWP_NOSIZE | SWP_NOZORDER );
}
}
while ((hwndChild=GetWindow( hwndChild, GW_HWNDNEXT )) != (HWND)NULL);
}
hwndChild = GetWindow(hwndParentDlg,GW_CHILD);
if(hwndStc32)
{
GetWindowRect(hwndStc32,&rectStc32);
MapWindowPoints( 0, hwndChildDlg,(LPPOINT)&rectStc32,2);
ptMoveCtl.x = rectStc32.left - 0;
ptMoveCtl.y = rectStc32.top - 0;
if (hwndChild )
{
do
{
if(hwndChild != hwndChildDlg)
{
if (GetWindowLongA( hwndChild, GWL_STYLE ) & WS_MAXIMIZE)
continue;
GetWindowRect(hwndChild,&rectCtrl);
MapWindowPoints( 0, hwndParentDlg,(LPPOINT)&rectCtrl,2);
rectCtrl.left += ptMoveCtl.x;
rectCtrl.top += ptMoveCtl.y;
SetWindowPos( hwndChild, 0, rectCtrl.left, rectCtrl.top,
rectCtrl.right-rectCtrl.left,rectCtrl.bottom-rectCtrl.top,
SWP_NOSIZE |SWP_NOZORDER );
}
}
while ((hwndChild=GetWindow( hwndChild, GW_HWNDNEXT )) != (HWND)NULL);
}
}
}
HRESULT WINAPI FileOpenDlgProcUserTemplate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(GetParent(hwnd),FileOpenDlgInfosStr);
switch(uMsg)
{
case WM_INITDIALOG:
{
fodInfos = (FileOpenDlgInfos *)lParam;
lParam = (LPARAM) fodInfos->ofnInfos;
ArrangeCtrlPositions(hwnd,GetParent(hwnd));
if(fodInfos && (fodInfos->ofnInfos->Flags & OFN_ENABLEHOOK) && fodInfos->ofnInfos->lpfnHook)
return CallWindowProcA((WNDPROC)fodInfos->ofnInfos->lpfnHook,hwnd,uMsg,wParam,lParam);
return 0;
}
}
if(fodInfos && (fodInfos->ofnInfos->Flags & OFN_ENABLEHOOK) && fodInfos->ofnInfos->lpfnHook )
return CallWindowProcA((WNDPROC)fodInfos->ofnInfos->lpfnHook,hwnd,uMsg,wParam,lParam);
return DefWindowProcA(hwnd,uMsg,wParam,lParam);
}
HWND CreateTemplateDialog(FileOpenDlgInfos *fodInfos,HWND hwnd)
{
LPCVOID template;
HRSRC hRes;
HANDLE hDlgTmpl = 0;
HWND hChildDlg = 0;
if (fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATE || fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATEHANDLE)
{
if (fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATEHANDLE)
{
if( !(template = LockResource( fodInfos->ofnInfos->hInstance)))
{
COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
return (HWND)NULL;
}
}
else
{
if (!(hRes = FindResourceA(MapHModuleSL(fodInfos->ofnInfos->hInstance),
(fodInfos->ofnInfos->lpTemplateName), RT_DIALOGA)))
{
COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
return (HWND)NULL;
}
if (!(hDlgTmpl = LoadResource( MapHModuleSL(fodInfos->ofnInfos->hInstance),
hRes )) ||
!(template = LockResource( hDlgTmpl )))
{
COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
return (HWND)NULL;
}
}
hChildDlg= CreateDialogIndirectParamA(fodInfos->ofnInfos->hInstance,template,hwnd,(DLGPROC)FileOpenDlgProcUserTemplate,(LPARAM)fodInfos);
if(hChildDlg)
{
ShowWindow(hChildDlg,SW_SHOW);
return hChildDlg;
}
}
else if(fodInfos->ofnInfos->Flags & OFN_ENABLEHOOK && fodInfos->ofnInfos->lpfnHook)
{
RECT rectHwnd;
DLGTEMPLATE tmplate;
GetClientRect(hwnd,&rectHwnd);
tmplate.style = WS_CHILD | WS_CLIPSIBLINGS;
tmplate.dwExtendedStyle = 0;
tmplate.cdit = 0;
tmplate.x = 0;
tmplate.y = 0;
tmplate.cx = rectHwnd.right-rectHwnd.left;
tmplate.cy = rectHwnd.bottom-rectHwnd.top;
return CreateDialogIndirectParamA(fodInfos->ofnInfos->hInstance,&tmplate,hwnd,(DLGPROC)FileOpenDlgProcUserTemplate,(LPARAM)fodInfos);
}
return (HWND)NULL;
}
/***********************************************************************
* SendCustomDlgNotificationMessage
*
* Send CustomDialogNotification (CDN_FIRST -- CDN_LAST) message to the custom template dialog
*/
HRESULT SendCustomDlgNotificationMessage(HWND hwndParentDlg, UINT uCode)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwndParentDlg,FileOpenDlgInfosStr);
if(!fodInfos)
return 0;
if(fodInfos->DlgInfos.hwndCustomDlg)
{
OFNOTIFYA ofnNotify;
ofnNotify.hdr.hwndFrom=hwndParentDlg;
ofnNotify.hdr.idFrom=0;
ofnNotify.hdr.code = uCode;
ofnNotify.lpOFN = fodInfos->ofnInfos;
return SendMessageA(fodInfos->DlgInfos.hwndCustomDlg,WM_NOTIFY,0,(LPARAM)&ofnNotify);
}
return TRUE;
}
/***********************************************************************
* FILEDLG95_HandleCustomDialogMessages
*
* Handle Custom Dialog Messages (CDM_FIRST -- CDM_LAST) messages
*/
HRESULT FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LPSTR lpstrFileSpec;
int reqSize;
char lpstrPath[MAX_PATH];
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
if(!fodInfos) return -1;
switch(uMsg)
{
case CDM_GETFILEPATH:
GetDlgItemTextA(hwnd,IDC_FILENAME,lpstrPath, sizeof(lpstrPath));
lpstrFileSpec = (LPSTR)COMDLG32_PathFindFilenameA(lpstrPath);
if (lpstrFileSpec==lpstrPath)
{
char lpstrCurrentDir[MAX_PATH];
/* Prepend the current path */
COMDLG32_SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent,lpstrCurrentDir);
if ((LPSTR)lParam!=NULL)
wsnprintfA((LPSTR)lParam,(int)wParam,"%s\\%s",lpstrCurrentDir,lpstrPath);
reqSize=strlen(lpstrCurrentDir)+1+strlen(lpstrPath)+1;
}
else
{
lstrcpynA((LPSTR)lParam,(LPSTR)lpstrPath,(int)wParam);
reqSize=strlen(lpstrPath);
}
/* return the required buffer size */
return reqSize;
case CDM_GETFOLDERPATH:
COMDLG32_SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent,lpstrPath);
if ((LPSTR)lParam!=NULL)
lstrcpynA((LPSTR)lParam,lpstrPath,(int)wParam);
return strlen(lpstrPath);
case CDM_GETSPEC:
reqSize=GetDlgItemTextA(hwnd,IDC_FILENAME,lpstrPath, sizeof(lpstrPath));
lpstrFileSpec = (LPSTR)COMDLG32_PathFindFilenameA(lpstrPath);
if ((LPSTR)lParam!=NULL)
lstrcpynA((LPSTR)lParam, lpstrFileSpec, (int)wParam);
return strlen(lpstrFileSpec);
case CDM_SETCONTROLTEXT:
if ( 0 != lParam )
SetDlgItemTextA( hwnd, (UINT) wParam, (LPSTR) lParam );
return TRUE;
case CDM_HIDECONTROL:
case CDM_SETDEFEXT:
FIXME("CDM_HIDECONTROL,CDM_SETCONTROLTEXT,CDM_SETDEFEXT not implemented\n");
return -1;
}
return TRUE;
}
/***********************************************************************
* FileOpenDlgProc95
*
* File open dialog procedure
*/
HRESULT WINAPI FileOpenDlgProc95(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_INITDIALOG :
/* Adds the FileOpenDlgInfos in the property list of the dialog
so it will be easily accessible through a GetPropA(...) */
SetPropA(hwnd, FileOpenDlgInfosStr, (HANDLE) lParam);
FILEDLG95_OnWMInitDialog(hwnd, wParam, lParam);
((FileOpenDlgInfos *)lParam)->DlgInfos.hwndCustomDlg =
CreateTemplateDialog((FileOpenDlgInfos *)lParam,hwnd);
SendCustomDlgNotificationMessage(hwnd,CDN_INITDONE);
return 0;
case WM_COMMAND:
return FILEDLG95_OnWMCommand(hwnd, wParam, lParam);
case WM_DRAWITEM:
{
switch(((LPDRAWITEMSTRUCT)lParam)->CtlID)
{
case IDC_LOOKIN:
FILEDLG95_LOOKIN_DrawItem((LPDRAWITEMSTRUCT) lParam);
return TRUE;
}
}
return FALSE;
case WM_GETISHELLBROWSER:
return FILEDLG95_OnWMGetIShellBrowser(hwnd);
case WM_DESTROY:
RemovePropA(hwnd, FileOpenDlgInfosStr);
return FALSE;
case WM_NOTIFY:
{
LPNMHDR lpnmh = (LPNMHDR)lParam;
UINT stringId = -1;
/* set up the button tooltips strings */
if(TTN_GETDISPINFOA == lpnmh->code )
{
LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
switch(lpnmh->idFrom )
{
/* Up folder button */
case FCIDM_TB_UPFOLDER:
stringId = IDS_UPFOLDER;
break;
/* New folder button */
case FCIDM_TB_NEWFOLDER:
stringId = IDS_NEWFOLDER;
break;
/* List option button */
case FCIDM_TB_SMALLICON:
stringId = IDS_LISTVIEW;
break;
/* Details option button */
case FCIDM_TB_REPORTVIEW:
stringId = IDS_REPORTVIEW;
break;
}
lpdi->hinst = COMMDLG_hInstance32;
lpdi->lpszText = (LPSTR) stringId;
}
return FALSE;
}
default :
if(uMsg >= CDM_FIRST && uMsg <= CDM_LAST)
return FILEDLG95_HandleCustomDialogMessages(hwnd, uMsg, wParam, lParam);
return FALSE;
}
}
/***********************************************************************
* FILEDLG95_OnWMInitDialog
*
* WM_INITDIALOG message handler
*/
static LRESULT FILEDLG95_OnWMInitDialog(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
LPITEMIDLIST pidlItemId;
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) lParam;
TRACE("\n");
/* Make sure the common control DLL is loaded */
InitCommonControls();
/* Initialise shell objects */
FILEDLG95_SHELL_Init(hwnd);
/* Initialise dialog UI */
FILEDLG95_InitUI(hwnd);
/* Initialize the Look In combo box*/
FILEDLG95_LOOKIN_Init(fodInfos->DlgInfos.hwndLookInCB);
/* Initialize the filter combo box */
FILEDLG95_FILETYPE_Init(hwnd);
/* Get the initial directory pidl */
if(!(pidlItemId = GetPidlFromName(fodInfos->Shell.FOIShellFolder,fodInfos->ofnInfos->lpstrInitialDir)))
{
char path[MAX_PATH];
GetCurrentDirectoryA(MAX_PATH,path);
pidlItemId = GetPidlFromName(fodInfos->Shell.FOIShellFolder,
path);
}
/* Browse to the initial directory */
IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,pidlItemId,SBSP_RELATIVE);
/* Free pidlItem memory */
COMDLG32_SHFree(pidlItemId);
return TRUE;
}
/***********************************************************************
* FILEDLG95_Clean
*
* Regroups all the cleaning functions of the filedlg
*/
void FILEDLG95_Clean(HWND hwnd)
{
FILEDLG95_FILETYPE_Clean(hwnd);
FILEDLG95_LOOKIN_Clean(hwnd);
FILEDLG95_SHELL_Clean(hwnd);
}
/***********************************************************************
* FILEDLG95_OnWMCommand
*
* WM_COMMAND message handler
*/
static LRESULT FILEDLG95_OnWMCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
{
WORD wNotifyCode = HIWORD(wParam); /* notification code */
WORD wID = LOWORD(wParam); /* item, control, or accelerator identifier */
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
switch(wID)
{
/* OK button */
case IDOK:
if(FILEDLG95_OnOpen(hwnd))
SendCustomDlgNotificationMessage(hwnd,CDN_FILEOK);
break;
/* Cancel button */
case IDCANCEL:
FILEDLG95_Clean(hwnd);
EndDialog(hwnd, FALSE);
break;
/* Filetype combo box */
case IDC_FILETYPE:
FILEDLG95_FILETYPE_OnCommand(hwnd,wNotifyCode);
break;
/* LookIn combo box */
case IDC_LOOKIN:
FILEDLG95_LOOKIN_OnCommand(hwnd,wNotifyCode);
break;
/* --- toolbar --- */
/* Up folder button */
case FCIDM_TB_UPFOLDER:
FILEDLG95_SHELL_UpFolder(hwnd);
break;
/* New folder button */
case FCIDM_TB_NEWFOLDER:
FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_NEWFOLDER);
break;
/* List option button */
case FCIDM_TB_SMALLICON:
FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_VIEWLIST);
break;
/* Details option button */
case FCIDM_TB_REPORTVIEW:
FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_VIEWDETAILS);
break;
case IDC_FILENAME:
break;
}
/* Do not use the listview selection anymore */
fodInfos->DlgInfos.dwDlgProp &= ~FODPROP_USEVIEW;
return 0;
}
/***********************************************************************
* FILEDLG95_OnWMGetIShellBrowser
*
* WM_GETISHELLBROWSER message handler
*/
static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
TRACE("\n");
SetWindowLongA(hwnd,DWL_MSGRESULT,(LONG)fodInfos->Shell.FOIShellBrowser);
return TRUE;
}
/***********************************************************************
* FILEDLG95_InitUI
*
*/
static LRESULT FILEDLG95_InitUI(HWND hwnd)
{
TBBUTTON tbb[] =
{{VIEW_PARENTFOLDER, FCIDM_TB_UPFOLDER, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
{0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0, 0}, 0, 0 },
{VIEW_NEWFOLDER, FCIDM_TB_NEWFOLDER, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
{0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0, 0}, 0, 0 },
{VIEW_LIST, FCIDM_TB_SMALLICON, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
{VIEW_DETAILS, FCIDM_TB_REPORTVIEW, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
};
TBADDBITMAP tba = { HINST_COMMCTRL, IDB_VIEW_SMALL_COLOR };
RECT rectTB;
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
TRACE("%p\n", fodInfos);
/* Get the hwnd of the controls */
fodInfos->DlgInfos.hwndFileName = GetDlgItem(hwnd,IDC_FILENAME);
fodInfos->DlgInfos.hwndFileTypeCB = GetDlgItem(hwnd,IDC_FILETYPE);
fodInfos->DlgInfos.hwndLookInCB = GetDlgItem(hwnd,IDC_LOOKIN);
/* construct the toolbar */
GetWindowRect(GetDlgItem(hwnd,IDC_TOOLBARSTATIC),&rectTB);
MapWindowPoints( 0, hwnd,(LPPOINT)&rectTB,2);
fodInfos->DlgInfos.hwndTB = CreateWindowExA(0, TOOLBARCLASSNAMEA, (LPSTR) NULL,
WS_CHILD | WS_GROUP | TBSTYLE_TOOLTIPS | CCS_NODIVIDER | CCS_NORESIZE,
0, 0, 150, 26,
hwnd, (HMENU) IDC_TOOLBAR, COMMDLG_hInstance32, NULL);
SetWindowPos(fodInfos->DlgInfos.hwndTB, 0,
rectTB.left,rectTB.top, rectTB.right-rectTB.left, rectTB.bottom-rectTB.top,
SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOZORDER );
SendMessageA(fodInfos->DlgInfos.hwndTB, TB_BUTTONSTRUCTSIZE, (WPARAM) sizeof(TBBUTTON), 0);
/* fixme: use TB_LOADIMAGES when implemented */
/* SendMessageA(fodInfos->DlgInfos.hwndTB, TB_LOADIMAGES, (WPARAM) IDB_VIEW_SMALL_COLOR, HINST_COMMCTRL);*/
SendMessageA(fodInfos->DlgInfos.hwndTB, TB_ADDBITMAP, (WPARAM) 12, (LPARAM) &tba);
SendMessageA(fodInfos->DlgInfos.hwndTB, TB_ADDBUTTONSA, (WPARAM) 6,(LPARAM) &tbb);
SendMessageA(fodInfos->DlgInfos.hwndTB, TB_AUTOSIZE, 0, 0);
/* Set the window text with the text specified in the OPENFILENAME structure */
if(fodInfos->ofnInfos->lpstrTitle)
{
SetWindowTextA(hwnd,fodInfos->ofnInfos->lpstrTitle);
}
else if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
{
SetWindowTextA(hwnd,"Save");
}
/* Initialise the file name edit control */
if(fodInfos->ofnInfos->lpstrFile)
{
SetDlgItemTextA(hwnd,IDC_FILENAME,fodInfos->ofnInfos->lpstrFile);
}
/* Must the open as read only check box be checked ?*/
if(fodInfos->ofnInfos->Flags & OFN_READONLY)
{
SendDlgItemMessageA(hwnd,IDC_OPENREADONLY,BM_SETCHECK,(WPARAM)TRUE,0);
}
/* Must the open as read only check box be hid ?*/
if(fodInfos->ofnInfos->Flags & OFN_HIDEREADONLY)
{
ShowWindow(GetDlgItem(hwnd,IDC_OPENREADONLY),SW_HIDE);
}
/* Must the help button be hid ?*/
if (!(fodInfos->ofnInfos->Flags & OFN_SHOWHELP))
{
ShowWindow(GetDlgItem(hwnd, pshHelp), SW_HIDE);
}
/* Resize the height, if open as read only checkbox ad help button
are hidden */
if ( (fodInfos->ofnInfos->Flags & OFN_HIDEREADONLY) &&
(!(fodInfos->ofnInfos->Flags & OFN_SHOWHELP)) )
{
RECT rectDlg, rectHelp, rectCancel;
GetWindowRect(hwnd, &rectDlg);
GetWindowRect(GetDlgItem(hwnd, pshHelp), &rectHelp);
GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rectCancel);
/* subtract the height of the help button plus the space between
the help button and the cancel button to the height of the dialog */
SetWindowPos(hwnd, 0, 0, 0, rectDlg.right-rectDlg.left,
(rectDlg.bottom-rectDlg.top) - (rectHelp.bottom - rectCancel.bottom),
SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER);
}
/* change Open to Save */
if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
{
SetDlgItemTextA(hwnd,IDOK,"Save");
}
return 0;
}
/***********************************************************************
* FILEDLG95_OnOpenMultipleFiles
*
* Handles the opening of multiple files.
*
*/
BOOL FILEDLG95_OnOpenMultipleFiles(HWND hwnd, LPSTR lpstrFileList, UINT nFileCount, UINT sizeUsed)
{
CHAR lpstrPathSpec[MAX_PATH] = "";
CHAR lpstrTempFileList[MAX_PATH] = "";
LPSTR lpstrFile;
UINT sizePath;
UINT nCount;
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
TRACE("\n");
lpstrFile = fodInfos->ofnInfos->lpstrFile;
COMDLG32_SHGetPathFromIDListA( fodInfos->ShellInfos.pidlAbsCurrent, lpstrPathSpec );
sizePath = lstrlenA( lpstrPathSpec );
memset( lpstrFile, 0x0, fodInfos->ofnInfos->nMaxFile * sizeof(CHAR) );
if ( fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST ||
!(fodInfos->ofnInfos->Flags & OFN_EXPLORER ))
{
LPSTR lpstrTemp = lpstrFileList;
for ( nCount = 0; nCount < nFileCount; nCount++ )
{
WIN32_FIND_DATAA findData;
CHAR lpstrFindFile[MAX_PATH];
memset( lpstrFindFile, 0x0, MAX_PATH * sizeof(CHAR) );
lstrcpyA( lpstrFindFile, lpstrPathSpec );
lstrcatA( lpstrFindFile, "\\" );
lstrcatA( lpstrFindFile, lpstrTemp );
if ( FindFirstFileA( lpstrFindFile, &findData ) == INVALID_HANDLE_VALUE )
{
CHAR lpstrNotFound[100];
CHAR lpstrMsg[100];
CHAR tmp[400];
LoadStringA(COMMDLG_hInstance32, IDS_FILENOTFOUND, lpstrNotFound, 100);
LoadStringA(COMMDLG_hInstance32, IDS_VERIFYFILE, lpstrMsg, 100);
strcpy(tmp, lpstrFindFile);
strcat(tmp, "\n");
strcat(tmp, lpstrNotFound);
strcat(tmp, "\n");
strcat(tmp, lpstrMsg);
MessageBoxA(hwnd,
tmp,
fodInfos->ofnInfos->lpstrTitle,
MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
if (!(fodInfos->ofnInfos->Flags & OFN_EXPLORER ))
{
lstrcatA( lpstrTempFileList, findData.cAlternateFileName);
if ( nCount + 1 < nFileCount)
lstrcatA( lpstrTempFileList, " ");
}
lpstrTemp += strlen(lpstrFileList) + 1;
}
}
if ( fodInfos->ofnInfos->Flags & OFN_EXPLORER )
{
lstrcpyA( lpstrFile, lpstrPathSpec);
memcpy( lpstrFile + sizePath + 1, lpstrFileList, sizeof(CHAR) * sizeUsed );
}
else
{
memcpy( lpstrFile, lpstrTempFileList, sizeof(CHAR) * strlen(lpstrTempFileList));
}
fodInfos->ofnInfos->nFileOffset = sizePath + 1;
fodInfos->ofnInfos->nFileExtension = 0;
/* clean and exit */
FILEDLG95_Clean(hwnd);
return EndDialog(hwnd,TRUE);
}
/***********************************************************************
* FILEDLG95_OnOpen
*
* Ok button WM_COMMAND message handler
*
* If the function succeeds, the return value is nonzero.
*/
BOOL FILEDLG95_OnOpen(HWND hwnd)
{
CHAR lpstrSpecifiedByUser[MAX_PATH];
CHAR lpstrFileList[MAX_PATH];
LPSTR lpstrFile;
UINT nStrCharCount = 0;
UINT nFileCount = 0;
UINT nFileIndex = 0;
UINT sizeUsed = 0;
UINT nStrLen = 0;
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
lpstrSpecifiedByUser[0]=0;
TRACE("\n");
lpstrFile = fodInfos->ofnInfos->lpstrFile;
GetDlgItemTextA(hwnd, IDC_FILENAME, lpstrSpecifiedByUser, MAX_PATH);
nStrLen = strlen(lpstrSpecifiedByUser);
while ( nStrCharCount <= nStrLen )
{
if ( lpstrSpecifiedByUser[nStrCharCount]=='"' )
{
nStrCharCount++;
while ((lpstrSpecifiedByUser[nStrCharCount]!='"') &&
(nStrCharCount <= nStrLen))
{
lpstrFileList[nFileIndex++] = lpstrSpecifiedByUser[nStrCharCount];
nStrCharCount++;
sizeUsed++;
}
lpstrFileList[nFileIndex++] = '\0';
sizeUsed++;
nFileCount++;
}
nStrCharCount++;
}
if(nFileCount > 0)
return FILEDLG95_OnOpenMultipleFiles(hwnd, lpstrFileList, nFileCount, sizeUsed);
if (nStrLen)
{
LPSHELLFOLDER psfDesktop;
LPITEMIDLIST browsePidl;
LPSTR lpstrFileSpec;
LPSTR lpstrTemp;
char lpstrPathSpec[MAX_PATH];
char lpstrCurrentDir[MAX_PATH];
char lpstrPathAndFile[MAX_PATH];
lpstrPathSpec[0] = '\0';
lpstrCurrentDir[0] = '\0';
lpstrPathAndFile[0] = '\0';
/* Separate the file spec from the path spec
e.g.:
lpstrSpecifiedByUser lpstrPathSpec lpstrFileSpec
C:\TEXT1\TEXT2 C:\TEXT1 TEXT2
*/
if (nFileCount == 0)
{
lpstrFileSpec = (LPSTR)COMDLG32_PathFindFilenameA(lpstrSpecifiedByUser);
strcpy(lpstrPathSpec,lpstrSpecifiedByUser);
COMDLG32_PathRemoveFileSpecA(lpstrPathSpec);
}
/* Get the index of the selected item in the filetype combo box */
fodInfos->ofnInfos->nFilterIndex = (DWORD) CBGetCurSel(fodInfos->DlgInfos.hwndFileTypeCB);
/* nFilterIndex is 1 based while combo GetCurSel return zero based index */
fodInfos->ofnInfos->nFilterIndex++;
/* Get the current directory name */
COMDLG32_SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent,
lpstrCurrentDir);
/* Create an absolute path name */
if(lpstrSpecifiedByUser[1] != ':')
{
switch(lpstrSpecifiedByUser[0])
{
/* Add drive spec \TEXT => C:\TEXT */
case '\\':
{
int lenPathSpec=strlen(lpstrPathSpec);
int iCopy = (lenPathSpec!=0?2:3);
memmove(lpstrPathSpec+iCopy,lpstrPathSpec,lenPathSpec);
strncpy(lpstrPathSpec,lpstrCurrentDir,iCopy);
}
break;
/* Go to parent ..\TEXT */
case '.':
{
int iSize;
char lpstrTmp2[MAX_PATH];
LPSTR lpstrTmp = strrchr(lpstrCurrentDir,'\\');
iSize = lpstrTmp - lpstrCurrentDir;
strncpy(lpstrTmp2,lpstrCurrentDir,iSize + 1);
if(strlen(lpstrSpecifiedByUser) <= 3)
*lpstrFileSpec='\0';
if(strcmp(lpstrPathSpec,".."))
strcat(lpstrTmp2,&lpstrPathSpec[3]);
strcpy(lpstrPathSpec,lpstrTmp2);
}
break;
default:
{
char lpstrTmp[MAX_PATH];
if(strcmp(&lpstrCurrentDir[strlen(lpstrCurrentDir)-1],"\\"))
strcat(lpstrCurrentDir,"\\");
strcpy(lpstrTmp,lpstrCurrentDir);
strcat(lpstrTmp,lpstrPathSpec);
strcpy(lpstrPathSpec,lpstrTmp);
}
} /* end switch */
}
if(strlen(lpstrPathSpec))
{
/* Browse to the right directory */
COMDLG32_SHGetDesktopFolder(&psfDesktop);
if((browsePidl = GetPidlFromName(psfDesktop,lpstrPathSpec)))
{
/* Browse to directory */
IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
browsePidl,
SBSP_ABSOLUTE);
COMDLG32_SHFree(browsePidl);
}
else
{
/* Path does not exist */
if(fodInfos->ofnInfos->Flags & OFN_PATHMUSTEXIST)
{
MessageBoxA(hwnd,
"Path does not exist",
fodInfos->ofnInfos->lpstrTitle,
MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
}
strcat(lpstrPathAndFile,lpstrPathSpec);
IShellFolder_Release(psfDesktop);
}
else
{
strcat(lpstrPathAndFile,lpstrCurrentDir);
}
/* Create the path and file string */
COMDLG32_PathAddBackslashA(lpstrPathAndFile);
strcat(lpstrPathAndFile,lpstrFileSpec);
/* Update the edit field */
SetDlgItemTextA(hwnd,IDC_FILENAME,lpstrFileSpec);
SendDlgItemMessageA(hwnd,IDC_FILENAME,EM_SETSEL,0,-1);
/* Don't go further if we dont have a file spec */
if(!strlen(lpstrFileSpec) || !strcmp(lpstrFileSpec,lpstrPathSpec))
return FALSE;
/* Time to check lpstrFileSpec */
/* search => contains * or ? */
/* browse => contains a directory name */
/* file => contains a file name */
/* Check if this is a search */
if(strchr(lpstrFileSpec,'*') || strchr(lpstrFileSpec,'?'))
{
int iPos;
/* Set the current filter with the current selection */
if(fodInfos->ShellInfos.lpstrCurrentFilter)
MemFree((LPVOID)fodInfos->ShellInfos.lpstrCurrentFilter);
fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc((strlen(lpstrFileSpec)+1)*2);
lstrcpyAtoW(fodInfos->ShellInfos.lpstrCurrentFilter,
(LPSTR)strlwr((LPSTR)lpstrFileSpec));
IShellView_Refresh(fodInfos->Shell.FOIShellView);
if(-1 < (iPos = FILEDLG95_FILETYPE_SearchExt(fodInfos->DlgInfos.hwndFileTypeCB,
lpstrFileSpec)))
CBSetCurSel(fodInfos->DlgInfos.hwndFileTypeCB,iPos);
return FALSE;
}
/* browse if the user specified a directory */
browsePidl = GetPidlFromName(fodInfos->Shell.FOIShellFolder,
lpstrFileSpec);
if (!browsePidl) /* not a directory check the specified file exists */
{
int iExt;
char lpstrFileSpecTemp[MAX_PATH];
LPSTR lpstrExt;
LPSTR lpOrg;
LPSTR lpBuf;
iExt = CBGetCurSel(fodInfos->DlgInfos.hwndFileTypeCB);
lpOrg = (LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB, iExt);
if ((int)lpOrg == -1)
lpOrg = NULL; /* we get -1 if the filetype LB is empty */
lpstrExt = lpOrg;
/*
add user specified extentions to the file one by one and
check if the file exists
*/
while(lpOrg)
{
int i;
if ((lpstrExt = strchr(lpOrg, ';')))
{
i = lpstrExt - lpOrg;
}
else
i = strlen(lpOrg);
lpBuf = MemAlloc(i+1);
strncpy(lpBuf, lpOrg, i);
lpBuf[i] = 0;
strcpy(lpstrFileSpecTemp, lpstrFileSpec);
if (lpstrFileSpecTemp[strlen(lpstrFileSpecTemp)-1] == '.')
{
if (strchr(lpBuf, '.'))
strcat(lpstrFileSpecTemp, (strchr(lpBuf, '.')) + 1);
}
else
strcat(lpstrFileSpecTemp, strchr(lpBuf, '.'));
browsePidl = GetPidlFromName(fodInfos->Shell.FOIShellFolder,
lpstrFileSpecTemp);
MemFree((void *)lpBuf);
if (browsePidl)
{
strcpy(lpstrFileSpec,lpstrFileSpecTemp);
break;
}
if (lpstrExt)
lpOrg = lpstrExt+1;
else
lpOrg = NULL;
}
}
if (browsePidl)
{
ULONG ulAttr = SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
int nMsgBoxRet;
char lpstrFileExist[MAX_PATH + 50];
IShellFolder_GetAttributesOf(fodInfos->Shell.FOIShellFolder,
1,
&browsePidl,
&ulAttr);
/* Browse to directory if it is a folder */
if (ulAttr & SFGAO_FOLDER)
{
if(FAILED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
browsePidl,
SBSP_RELATIVE)))
{
if(fodInfos->ofnInfos->Flags & OFN_PATHMUSTEXIST)
{
MessageBoxA(hwnd,
"Path does not exist",
fodInfos->ofnInfos->lpstrTitle,
MB_OK | MB_ICONEXCLAMATION);
COMDLG32_SHFree(browsePidl);
return FALSE;
}
}
COMDLG32_SHFree(browsePidl);
return FALSE;
}
/* The file does exist, so ask the user if we should overwrite it */
if((fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG) &&
(fodInfos->ofnInfos->Flags & OFN_OVERWRITEPROMPT))
{
strcpy(lpstrFileExist, lpstrFileSpec);
strcat(lpstrFileExist, " already exists.\nDo you want to replace it?");
nMsgBoxRet = MessageBoxA(hwnd,
lpstrFileExist,
fodInfos->ofnInfos->lpstrTitle,
MB_YESNO | MB_ICONEXCLAMATION);
if (nMsgBoxRet == IDNO)
{
COMDLG32_SHFree(browsePidl);
return FALSE;
}
}
COMDLG32_SHFree(browsePidl);
}
else
{
/* File does not exist in current directory */
/* The selected file does not exist */
/* Tell the user the selected does not exist */
if(fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST)
{
char lpstrNotFound[100];
char lpstrMsg[100];
char tmp[400];
LoadStringA(COMMDLG_hInstance32,
IDS_FILENOTFOUND,
lpstrNotFound,
100);
LoadStringA(COMMDLG_hInstance32,
IDS_VERIFYFILE,
lpstrMsg,
100);
strcpy(tmp,fodInfos->ofnInfos->lpstrFile);
strcat(tmp,"\n");
strcat(tmp,lpstrNotFound);
strcat(tmp,"\n");
strcat(tmp,lpstrMsg);
MessageBoxA(hwnd,
tmp,
fodInfos->ofnInfos->lpstrTitle,
MB_OK | MB_ICONEXCLAMATION);
return FALSE;
}
/* Ask the user if he wants to create the file*/
if(fodInfos->ofnInfos->Flags & OFN_CREATEPROMPT)
{
char tmp[100];
LoadStringA(COMMDLG_hInstance32,IDS_CREATEFILE,tmp,100);
if(IDYES == MessageBoxA(hwnd,tmp,fodInfos->ofnInfos->lpstrTitle,
MB_YESNO | MB_ICONQUESTION))
{
/* Create the file, clean and exit */
FILEDLG95_Clean(hwnd);
return EndDialog(hwnd,TRUE);
}
return FALSE;
}
}
/* Open the selected file */
/* Check file extension */
if(!strrchr(lpstrPathAndFile,'.'))
{
/* if the file has no extension, append the selected
extension of the filetype combo box */
int iExt;
LPSTR lpstrExt;
iExt = CBGetCurSel(fodInfos->DlgInfos.hwndFileTypeCB);
lpstrTemp = (LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,iExt);
if((LPSTR)-1 != lpstrTemp)
{
if((lpstrExt = strchr(lpstrTemp,';')))
{
int i = lpstrExt - lpstrTemp;
lpstrExt = MemAlloc(i);
strncpy(lpstrExt,&lpstrTemp[1],i-1);
}
else
{
lpstrExt = MemAlloc(strlen(lpstrTemp));
strcpy(lpstrExt,&lpstrTemp[1]);
}
if(!strcmp(&lpstrExt[1],"*") && fodInfos->ofnInfos->lpstrDefExt)
{
MemFree(lpstrExt);
lpstrExt = MemAlloc(strlen(fodInfos->ofnInfos->lpstrDefExt)+2);
strcat(lpstrExt,".");
strcat(lpstrExt,(LPSTR) fodInfos->ofnInfos->lpstrDefExt);
}
strcat(lpstrPathAndFile,lpstrExt);
MemFree( lpstrExt );
}
}
/* Check that size size of the file does not exceed buffer size */
if(strlen(lpstrPathAndFile) > fodInfos->ofnInfos->nMaxFile)
{
/* set error FNERR_BUFFERTOSMALL */
FILEDLG95_Clean(hwnd);
return EndDialog(hwnd,FALSE);
}
strcpy(fodInfos->ofnInfos->lpstrFile,lpstrPathAndFile);
/* Set the lpstrFileTitle of the OPENFILENAME structure */
if(fodInfos->ofnInfos->lpstrFileTitle)
strncpy(fodInfos->ofnInfos->lpstrFileTitle,
lpstrFileSpec,
fodInfos->ofnInfos->nMaxFileTitle);
/* Check if the file is to be opened as read only */
if(BST_CHECKED == SendDlgItemMessageA(hwnd,
IDC_OPENREADONLY,
BM_GETSTATE,0,0))
SetFileAttributesA(fodInfos->ofnInfos->lpstrFile,
FILE_ATTRIBUTE_READONLY);
/* nFileExtension and nFileOffset of OPENFILENAME structure */
lpstrTemp = strrchr(fodInfos->ofnInfos->lpstrFile,'\\');
fodInfos->ofnInfos->nFileOffset = lpstrTemp - fodInfos->ofnInfos->lpstrFile + 1;
lpstrTemp = strrchr(fodInfos->ofnInfos->lpstrFile,'.');
fodInfos->ofnInfos->nFileExtension = lpstrTemp - fodInfos->ofnInfos->lpstrFile + 1;
/* clean and exit */
FILEDLG95_Clean(hwnd);
return EndDialog(hwnd,TRUE);
}
return FALSE;
}
/***********************************************************************
* FILEDLG95_SHELL_Init
*
* Initialisation of the shell objects
*/
static HRESULT FILEDLG95_SHELL_Init(HWND hwnd)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
TRACE("\n");
/*
* Initialisation of the FileOpenDialogInfos structure
*/
/* Shell */
fodInfos->Shell.FOIShellView = NULL;
if(FAILED(COMDLG32_SHGetDesktopFolder(&fodInfos->Shell.FOIShellFolder)))
return E_FAIL;
/*ShellInfos */
fodInfos->ShellInfos.hwndOwner = hwnd;
fodInfos->ShellInfos.folderSettings.fFlags = 0;
/* Disable multi-select if flag not set */
if (!(fodInfos->ofnInfos->Flags & OFN_ALLOWMULTISELECT))
{
fodInfos->ShellInfos.folderSettings.fFlags |= FWF_SINGLESEL;
}
fodInfos->ShellInfos.folderSettings.fFlags |= FWF_AUTOARRANGE | FWF_ALIGNLEFT;
fodInfos->ShellInfos.folderSettings.ViewMode = FVM_LIST;
GetWindowRect(GetDlgItem(hwnd,IDC_SHELLSTATIC),&fodInfos->ShellInfos.rectView);
ScreenToClient(hwnd,(LPPOINT)&fodInfos->ShellInfos.rectView.left);
ScreenToClient(hwnd,(LPPOINT)&fodInfos->ShellInfos.rectView.right);
/* Construct the IShellBrowser interface */
fodInfos->Shell.FOIShellBrowser = IShellBrowserImpl_Construct(hwnd);
return NOERROR;
}
/***********************************************************************
* FILEDLG95_SHELL_ExecuteCommand
*
* Change the folder option and refresh the view
* If the function succeeds, the return value is nonzero.
*/
static BOOL FILEDLG95_SHELL_ExecuteCommand(HWND hwnd, LPCSTR lpVerb)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
IContextMenu * pcm;
TRACE("(0x%08x,%p)\n", hwnd, lpVerb);
if(SUCCEEDED(IShellView_GetItemObject(fodInfos->Shell.FOIShellView,
SVGIO_BACKGROUND,
&IID_IContextMenu,
(LPVOID*)&pcm)))
{
CMINVOKECOMMANDINFO ci;
ZeroMemory(&ci, sizeof(CMINVOKECOMMANDINFO));
ci.cbSize = sizeof(CMINVOKECOMMANDINFO);
ci.lpVerb = lpVerb;
ci.hwnd = hwnd;
IContextMenu_InvokeCommand(pcm, &ci);
IContextMenu_Release(pcm);
}
return FALSE;
}
/***********************************************************************
* FILEDLG95_SHELL_UpFolder
*
* Browse to the specified object
* If the function succeeds, the return value is nonzero.
*/
static BOOL FILEDLG95_SHELL_UpFolder(HWND hwnd)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
TRACE("\n");
if(SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
NULL,
SBSP_PARENT)))
{
return TRUE;
}
return FALSE;
}
/***********************************************************************
* FILEDLG95_SHELL_Clean
*
* Cleans the memory used by shell objects
*/
static void FILEDLG95_SHELL_Clean(HWND hwnd)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
TRACE("\n");
/* clean Shell interfaces */
IShellView_DestroyViewWindow(fodInfos->Shell.FOIShellView);
IShellView_Release(fodInfos->Shell.FOIShellView);
IShellFolder_Release(fodInfos->Shell.FOIShellFolder);
IShellBrowser_Release(fodInfos->Shell.FOIShellBrowser);
}
/***********************************************************************
* FILEDLG95_FILETYPE_Init
*
* Initialisation of the file type combo box
*/
static HRESULT FILEDLG95_FILETYPE_Init(HWND hwnd)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
TRACE("\n");
if(fodInfos->ofnInfos->lpstrFilter)
{
int iStrIndex = 0;
int iPos = 0;
LPSTR lpstrFilter;
LPSTR lpstrTmp;
for(;;)
{
/* filter is a list... title\0ext\0......\0\0
* Set the combo item text to the title and the item data
* to the ext
*/
char *lpstrExt = NULL;
LPSTR lpstrExtTmp = NULL;
/* Get the title */
lpstrTmp = (&((LPBYTE)fodInfos->ofnInfos->lpstrFilter)[iStrIndex]);
if(!strlen(lpstrTmp))
break;
iStrIndex += strlen(lpstrTmp) +1;
/* Get the extension */
lpstrExtTmp = (&((LPBYTE)fodInfos->ofnInfos->lpstrFilter)[iStrIndex]);
if(!lpstrExtTmp)
break;
lpstrExt = (LPSTR) MemAlloc(strlen(lpstrExtTmp)+1);
if(!lpstrExt)
break;
strcpy(lpstrExt,lpstrExtTmp);
iStrIndex += strlen(lpstrExt) +1;
/* Add the item at the end of the combo */
CBAddString(fodInfos->DlgInfos.hwndFileTypeCB,lpstrTmp);
CBSetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,iPos++,lpstrExt);
}
/* Set the current filter to the one specified
* in the initialisation structure
*/
/* set default filter index */
if(fodInfos->ofnInfos->nFilterIndex == 0 && fodInfos->ofnInfos->lpstrCustomFilter == NULL)
fodInfos->ofnInfos->nFilterIndex = 1;
/* First, check to make sure our index isn't out of bounds. */
if ( fodInfos->ofnInfos->nFilterIndex > iPos )
fodInfos->ofnInfos->nFilterIndex = iPos;
/* Get the current index selection. */
CBSetCurSel(fodInfos->DlgInfos.hwndFileTypeCB,
fodInfos->ofnInfos->nFilterIndex-1);
/* Get the corresponding text string from the combo box. */
lpstrFilter = (LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
fodInfos->ofnInfos->nFilterIndex-1);
if(lpstrFilter)
{
fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc((strlen(lpstrFilter)+1)*2);
lstrcpyAtoW(fodInfos->ShellInfos.lpstrCurrentFilter,strlwr(lpstrFilter));
}
}
return NOERROR;
}
/***********************************************************************
* FILEDLG95_FILETYPE_OnCommand
*
* WM_COMMAND of the file type combo box
* If the function succeeds, the return value is nonzero.
*/
static BOOL FILEDLG95_FILETYPE_OnCommand(HWND hwnd, WORD wNotifyCode)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
switch(wNotifyCode)
{
case CBN_SELENDOK:
{
LPSTR lpstrFilter;
/* Get the current item of the filetype combo box */
int iItem = CBGetCurSel(fodInfos->DlgInfos.hwndFileTypeCB);
/* set the current filter index - indexed from 1 */
fodInfos->ofnInfos->nFilterIndex = iItem + 1;
/* Set the current filter with the current selection */
if(fodInfos->ShellInfos.lpstrCurrentFilter)
MemFree((LPVOID)fodInfos->ShellInfos.lpstrCurrentFilter);
lpstrFilter = (LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
iItem);
if((int)lpstrFilter != CB_ERR)
{
fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc((strlen(lpstrFilter)+1)*2);
lstrcpyAtoW(fodInfos->ShellInfos.lpstrCurrentFilter,(LPSTR)strlwr((LPSTR)lpstrFilter));
SendCustomDlgNotificationMessage(hwnd,CDN_TYPECHANGE);
}
/* Refresh the actual view to display the included items*/
IShellView_Refresh(fodInfos->Shell.FOIShellView);
}
}
return FALSE;
}
/***********************************************************************
* FILEDLG95_FILETYPE_SearchExt
*
* Search for pidl in the lookin combo box
* returns the index of the found item
*/
static int FILEDLG95_FILETYPE_SearchExt(HWND hwnd,LPSTR lpstrExt)
{
int i = 0;
int iCount = CBGetCount(hwnd);
TRACE("\n");
for(;i<iCount;i++)
{
LPSTR ext = (LPSTR) CBGetItemDataPtr(hwnd,i);
if(!strcasecmp(lpstrExt,ext))
return i;
}
return -1;
}
/***********************************************************************
* FILEDLG95_FILETYPE_Clean
*
* Clean the memory used by the filetype combo box
*/
static void FILEDLG95_FILETYPE_Clean(HWND hwnd)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
int iPos;
int iCount = CBGetCount(fodInfos->DlgInfos.hwndFileTypeCB);
TRACE("\n");
/* Delete each string of the combo and their associated data */
for(iPos = iCount-1;iPos>=0;iPos--)
{
MemFree((LPVOID)(CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,iPos)));
CBDeleteString(fodInfos->DlgInfos.hwndFileTypeCB,iPos);
}
/* Current filter */
if(fodInfos->ShellInfos.lpstrCurrentFilter)
MemFree((LPVOID)fodInfos->ShellInfos.lpstrCurrentFilter);
}
/***********************************************************************
* FILEDLG95_LOOKIN_Init
*
* Initialisation of the look in combo box
*/
static HRESULT FILEDLG95_LOOKIN_Init(HWND hwndCombo)
{
IShellFolder *psfRoot, *psfDrives;
IEnumIDList *lpeRoot, *lpeDrives;
LPITEMIDLIST pidlDrives, pidlTmp, pidlTmp1, pidlAbsTmp;
LookInInfos *liInfos = MemAlloc(sizeof(LookInInfos));
TRACE("\n");
liInfos->iMaxIndentation = 0;
SetPropA(hwndCombo, LookInInfosStr, (HANDLE) liInfos);
CBSetItemHeight(hwndCombo,0,GetSystemMetrics(SM_CYSMICON));
/* Initialise data of Desktop folder */
COMDLG32_SHGetSpecialFolderLocation(0,CSIDL_DESKTOP,&pidlTmp);
FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND);
COMDLG32_SHFree(pidlTmp);
COMDLG32_SHGetSpecialFolderLocation(0,CSIDL_DRIVES,&pidlDrives);
COMDLG32_SHGetDesktopFolder(&psfRoot);
if (psfRoot)
{
/* enumerate the contents of the desktop */
if(SUCCEEDED(IShellFolder_EnumObjects(psfRoot, hwndCombo, SHCONTF_FOLDERS, &lpeRoot)))
{
while (S_OK == IEnumIDList_Next(lpeRoot, 1, &pidlTmp, NULL))
{
FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND);
/* special handling for CSIDL_DRIVES */
if (COMDLG32_PIDL_ILIsEqual(pidlTmp, pidlDrives))
{
if(SUCCEEDED(IShellFolder_BindToObject(psfRoot, pidlTmp, NULL, &IID_IShellFolder, (LPVOID*)&psfDrives)))
{
/* enumerate the drives */
if(SUCCEEDED(IShellFolder_EnumObjects(psfDrives, hwndCombo,SHCONTF_FOLDERS, &lpeDrives)))
{
while (S_OK == IEnumIDList_Next(lpeDrives, 1, &pidlTmp1, NULL))
{
pidlAbsTmp = COMDLG32_PIDL_ILCombine(pidlTmp, pidlTmp1);
FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlAbsTmp,LISTEND);
COMDLG32_SHFree(pidlAbsTmp);
COMDLG32_SHFree(pidlTmp1);
}
IEnumIDList_Release(lpeDrives);
}
IShellFolder_Release(psfDrives);
}
}
COMDLG32_SHFree(pidlTmp);
}
IEnumIDList_Release(lpeRoot);
}
}
IShellFolder_Release(psfRoot);
COMDLG32_SHFree(pidlDrives);
return NOERROR;
}
/***********************************************************************
* FILEDLG95_LOOKIN_DrawItem
*
* WM_DRAWITEM message handler
*/
static LRESULT FILEDLG95_LOOKIN_DrawItem(LPDRAWITEMSTRUCT pDIStruct)
{
COLORREF crWin = GetSysColor(COLOR_WINDOW);
COLORREF crHighLight = GetSysColor(COLOR_HIGHLIGHT);
COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
RECT rectText;
RECT rectIcon;
SHFILEINFOA sfi;
HIMAGELIST ilItemImage;
int iIndentation;
LPSFOLDER tmpFolder;
LookInInfos *liInfos = (LookInInfos *)GetPropA(pDIStruct->hwndItem,LookInInfosStr);
TRACE("\n");
if(pDIStruct->itemID == -1)
return 0;
if(!(tmpFolder = (LPSFOLDER) CBGetItemDataPtr(pDIStruct->hwndItem,
pDIStruct->itemID)))
return 0;
if(pDIStruct->itemID == liInfos->uSelectedItem)
{
ilItemImage = (HIMAGELIST) COMDLG32_SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
0,
&sfi,
sizeof (SHFILEINFOA),
SHGFI_PIDL | SHGFI_SMALLICON |
SHGFI_OPENICON | SHGFI_SYSICONINDEX |
SHGFI_DISPLAYNAME );
}
else
{
ilItemImage = (HIMAGELIST) COMDLG32_SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
0,
&sfi,
sizeof (SHFILEINFOA),
SHGFI_PIDL | SHGFI_SMALLICON |
SHGFI_SYSICONINDEX |
SHGFI_DISPLAYNAME);
}
/* Is this item selected ?*/
if(pDIStruct->itemState & ODS_SELECTED)
{
SetTextColor(pDIStruct->hDC,(0x00FFFFFF & ~(crText)));
SetBkColor(pDIStruct->hDC,crHighLight);
FillRect(pDIStruct->hDC,&pDIStruct->rcItem,(HBRUSH)crHighLight);
}
else
{
SetTextColor(pDIStruct->hDC,crText);
SetBkColor(pDIStruct->hDC,crWin);
FillRect(pDIStruct->hDC,&pDIStruct->rcItem,(HBRUSH)crWin);
}
/* Do not indent item if drawing in the edit of the combo*/
if(pDIStruct->itemState & ODS_COMBOBOXEDIT)
{
iIndentation = 0;
ilItemImage = (HIMAGELIST) COMDLG32_SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
0,
&sfi,
sizeof (SHFILEINFOA),
SHGFI_PIDL | SHGFI_SMALLICON | SHGFI_OPENICON
| SHGFI_SYSICONINDEX | SHGFI_DISPLAYNAME );
}
else
{
iIndentation = tmpFolder->m_iIndent;
}
/* Draw text and icon */
/* Initialise the icon display area */
rectIcon.left = pDIStruct->rcItem.left + ICONWIDTH/2 * iIndentation;
rectIcon.top = pDIStruct->rcItem.top;
rectIcon.right = rectIcon.left + ICONWIDTH;
rectIcon.bottom = pDIStruct->rcItem.bottom;
/* Initialise the text display area */
rectText.left = rectIcon.right;
rectText.top = pDIStruct->rcItem.top + YTEXTOFFSET;
rectText.right = pDIStruct->rcItem.right + XTEXTOFFSET;
rectText.bottom = pDIStruct->rcItem.bottom;
/* Draw the icon from the image list */
COMDLG32_ImageList_Draw(ilItemImage,
sfi.iIcon,
pDIStruct->hDC,
rectIcon.left,
rectIcon.top,
ILD_TRANSPARENT );
/* Draw the associated text */
if(sfi.szDisplayName)
TextOutA(pDIStruct->hDC,rectText.left,rectText.top,sfi.szDisplayName,strlen(sfi.szDisplayName));
return NOERROR;
}
/***********************************************************************
* FILEDLG95_LOOKIN_OnCommand
*
* LookIn combo box WM_COMMAND message handler
* If the function succeeds, the return value is nonzero.
*/
static BOOL FILEDLG95_LOOKIN_OnCommand(HWND hwnd, WORD wNotifyCode)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
TRACE("%p\n", fodInfos);
switch(wNotifyCode)
{
case CBN_SELENDOK:
{
LPSFOLDER tmpFolder;
int iItem;
iItem = CBGetCurSel(fodInfos->DlgInfos.hwndLookInCB);
if(!(tmpFolder = (LPSFOLDER) CBGetItemDataPtr(fodInfos->DlgInfos.hwndLookInCB,
iItem)))
return FALSE;
if(SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
tmpFolder->pidlItem,
SBSP_ABSOLUTE)))
{
return TRUE;
}
break;
}
}
return FALSE;
}
/***********************************************************************
* FILEDLG95_LOOKIN_AddItem
*
* Adds an absolute pidl item to the lookin combo box
* returns the index of the inserted item
*/
static int FILEDLG95_LOOKIN_AddItem(HWND hwnd,LPITEMIDLIST pidl, int iInsertId)
{
LPITEMIDLIST pidlNext;
SHFILEINFOA sfi;
SFOLDER *tmpFolder;
LookInInfos *liInfos;
TRACE("\n");
if(!pidl)
return -1;
if(!(liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr)))
return -1;
tmpFolder = MemAlloc(sizeof(SFOLDER));
tmpFolder->m_iIndent = 0;
/* Calculate the indentation of the item in the lookin*/
pidlNext = pidl;
while( (pidlNext=COMDLG32_PIDL_ILGetNext(pidlNext)) )
{
tmpFolder->m_iIndent++;
}
tmpFolder->pidlItem = COMDLG32_PIDL_ILClone(pidl);
if(tmpFolder->m_iIndent > liInfos->iMaxIndentation)
liInfos->iMaxIndentation = tmpFolder->m_iIndent;
COMDLG32_SHGetFileInfoA((LPSTR)pidl,
0,
&sfi,
sizeof(sfi),
SHGFI_DISPLAYNAME | SHGFI_SYSICONINDEX
| SHGFI_PIDL | SHGFI_SMALLICON | SHGFI_ATTRIBUTES);
if((sfi.dwAttributes & SFGAO_FILESYSANCESTOR) || (sfi.dwAttributes & SFGAO_FILESYSTEM))
{
int iItemID;
/* Add the item at the end of the list */
if(iInsertId < 0)
{
iItemID = CBAddString(hwnd,sfi.szDisplayName);
}
/* Insert the item at the iInsertId position*/
else
{
iItemID = CBInsertString(hwnd,sfi.szDisplayName,iInsertId);
}
CBSetItemDataPtr(hwnd,iItemID,tmpFolder);
return iItemID;
}
MemFree( tmpFolder );
return -1;
}
/***********************************************************************
* FILEDLG95_LOOKIN_InsertItemAfterParent
*
* Insert an item below its parent
*/
static int FILEDLG95_LOOKIN_InsertItemAfterParent(HWND hwnd,LPITEMIDLIST pidl)
{
LPITEMIDLIST pidlParent = GetParentPidl(pidl);
int iParentPos;
TRACE("\n");
iParentPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)pidlParent,SEARCH_PIDL);
if(iParentPos < 0)
{
iParentPos = FILEDLG95_LOOKIN_InsertItemAfterParent(hwnd,pidlParent);
}
/* Free pidlParent memory */
COMDLG32_SHFree((LPVOID)pidlParent);
return FILEDLG95_LOOKIN_AddItem(hwnd,pidl,iParentPos + 1);
}
/***********************************************************************
* FILEDLG95_LOOKIN_SelectItem
*
* Adds an absolute pidl item to the lookin combo box
* returns the index of the inserted item
*/
int FILEDLG95_LOOKIN_SelectItem(HWND hwnd,LPITEMIDLIST pidl)
{
int iItemPos;
LookInInfos *liInfos;
TRACE("\n");
iItemPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)pidl,SEARCH_PIDL);
liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr);
if(iItemPos < 0)
{
while(FILEDLG95_LOOKIN_RemoveMostExpandedItem(hwnd) > -1);
iItemPos = FILEDLG95_LOOKIN_InsertItemAfterParent(hwnd,pidl);
}
else
{
SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,iItemPos);
while(liInfos->iMaxIndentation > tmpFolder->m_iIndent)
{
int iRemovedItem;
if(-1 == (iRemovedItem = FILEDLG95_LOOKIN_RemoveMostExpandedItem(hwnd)))
break;
if(iRemovedItem < iItemPos)
iItemPos--;
}
}
CBSetCurSel(hwnd,iItemPos);
liInfos->uSelectedItem = iItemPos;
return 0;
}
/***********************************************************************
* FILEDLG95_LOOKIN_RemoveMostExpandedItem
*
* Remove the item with an expansion level over iExpansionLevel
*/
static int FILEDLG95_LOOKIN_RemoveMostExpandedItem(HWND hwnd)
{
int iItemPos;
LookInInfos *liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr);
TRACE("\n");
if(liInfos->iMaxIndentation <= 2)
return -1;
if((iItemPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)liInfos->iMaxIndentation,SEARCH_EXP)) >=0)
{
SFOLDER *tmpFolder;
tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,iItemPos);
CBDeleteString(hwnd,iItemPos);
liInfos->iMaxIndentation--;
return iItemPos;
}
return -1;
}
/***********************************************************************
* FILEDLG95_LOOKIN_SearchItem
*
* Search for pidl in the lookin combo box
* returns the index of the found item
*/
static int FILEDLG95_LOOKIN_SearchItem(HWND hwnd,WPARAM searchArg,int iSearchMethod)
{
int i = 0;
int iCount = CBGetCount(hwnd);
TRACE("\n");
for(;i<iCount;i++)
{
LPSFOLDER tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,i);
if(iSearchMethod == SEARCH_PIDL && COMDLG32_PIDL_ILIsEqual((LPITEMIDLIST)searchArg,tmpFolder->pidlItem))
return i;
if(iSearchMethod == SEARCH_EXP && tmpFolder->m_iIndent == (int)searchArg)
return i;
}
return -1;
}
/***********************************************************************
* FILEDLG95_LOOKIN_Clean
*
* Clean the memory used by the lookin combo box
*/
static void FILEDLG95_LOOKIN_Clean(HWND hwnd)
{
FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
int iPos;
int iCount = CBGetCount(fodInfos->DlgInfos.hwndLookInCB);
TRACE("\n");
/* Delete each string of the combo and their associated data */
for(iPos = iCount-1;iPos>=0;iPos--)
{
MemFree((LPVOID)(CBGetItemDataPtr(fodInfos->DlgInfos.hwndLookInCB,iPos)));
CBDeleteString(fodInfos->DlgInfos.hwndLookInCB,iPos);
}
/* LookInInfos structure */
RemovePropA(fodInfos->DlgInfos.hwndLookInCB,LookInInfosStr);
}
/*
* TOOLS
*/
/***********************************************************************
* GetName
*
* Get the pidl's display name (relative to folder) and
* put it in lpstrFileName.
*
* Return NOERROR on success,
* E_FAIL otherwise
*/
HRESULT GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl,DWORD dwFlags,LPSTR lpstrFileName)
{
STRRET str;
HRESULT hRes;
TRACE("%p %p\n", lpsf, pidl);
if(!lpsf)
{
HRESULT hRes;
COMDLG32_SHGetDesktopFolder(&lpsf);
hRes = GetName(lpsf,pidl,dwFlags,lpstrFileName);
IShellFolder_Release(lpsf);
return hRes;
}
/* Get the display name of the pidl relative to the folder */
if (SUCCEEDED(hRes = IShellFolder_GetDisplayNameOf(lpsf,
pidl,
dwFlags,
&str)))
{
return StrRetToBufA(&str, pidl,lpstrFileName, MAX_PATH);
}
return E_FAIL;
}
/***********************************************************************
* GetShellFolderFromPidl
*
* pidlRel is the item pidl relative
* Return the IShellFolder of the absolute pidl
*/
IShellFolder *GetShellFolderFromPidl(LPITEMIDLIST pidlAbs)
{
IShellFolder *psf = NULL,*psfParent;
TRACE("%p\n", pidlAbs);
if(SUCCEEDED(COMDLG32_SHGetDesktopFolder(&psfParent)))
{
psf = psfParent;
if(pidlAbs && pidlAbs->mkid.cb)
{
if(SUCCEEDED(IShellFolder_BindToObject(psfParent, pidlAbs, NULL, &IID_IShellFolder, (LPVOID*)&psf)))
{
IShellFolder_Release(psfParent);
return psf;
}
}
/* return the desktop */
return psfParent;
}
return NULL;
}
/***********************************************************************
* GetParentPidl
*
* Return the LPITEMIDLIST to the parent of the pidl in the list
*/
LPITEMIDLIST GetParentPidl(LPITEMIDLIST pidl)
{
LPITEMIDLIST pidlParent;
TRACE("%p\n", pidl);
pidlParent = COMDLG32_PIDL_ILClone(pidl);
COMDLG32_PIDL_ILRemoveLastID(pidlParent);
return pidlParent;
}
/***********************************************************************
* GetPidlFromName
*
* returns the pidl of the file name relative to folder
* NULL if an error occured
*/
LPITEMIDLIST GetPidlFromName(IShellFolder *psf,LPCSTR lpcstrFileName)
{
LPITEMIDLIST pidl;
ULONG ulEaten;
wchar_t lpwstrDirName[MAX_PATH];
TRACE("sf=%p file=%s\n", psf, lpcstrFileName);
if(!lpcstrFileName)
return NULL;
MultiByteToWideChar(CP_ACP,
MB_PRECOMPOSED,
lpcstrFileName,
-1,
(LPWSTR)lpwstrDirName,
MAX_PATH);
IShellFolder_ParseDisplayName(psf, 0,
NULL,
(LPWSTR)lpwstrDirName,
&ulEaten,
&pidl,
NULL);
return pidl;
}
/***********************************************************************
* GetFileExtension
*
*/
BOOL GetFileExtension(IShellFolder *psf,LPITEMIDLIST pidl,LPSTR lpstrFileExtension)
{
char FileName[MAX_PATH];
int result;
char *pdest;
int ch = '.';
if(SUCCEEDED(GetName(psf,pidl,SHGDN_NORMAL,FileName)))
{
if(!(pdest = strrchr( FileName, ch )))
return FALSE;
result = pdest - FileName + 1;
strcpy(lpstrFileExtension,&FileName[result]);
return TRUE;
}
return FALSE;
}
/*
* Memory allocation methods */
void *MemAlloc(UINT size)
{
return HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size);
}
void MemFree(void *mem)
{
if(mem)
{
HeapFree(GetProcessHeap(),0,mem);
}
}
Reference in New Issue View Git Blame Copy Permalink