able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/ext/url/fsassoc.c

1442 lines
42 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/* Look for BUILDBUILD to find build hacks. */
/* BUILDBUILD: My hacks to get this to build. */
#pragma warning(disable:4001) /* "single line comment" warning */
#include "project.h"
#pragma hdrstop
#include "urlshell.h"
#include <windowsx.h>
#include <mluisupp.h>
#undef NO_HELP
#include <help.h>
#pragma pack(1)
//#include <newexe.h> // newexe.h is broken with pack()!!!
#pragma pack()
#ifdef STRICT
#undef STRICT
#endif
#define NO_SHELL_HEAP_ALLOCATOR //Kludge to get around new mem heaps in nt
#define NO_MULTIMON // BUILDBUILD (scotth): no multimon stub functions
#define NO_SHELL_VALIDATION
#include <newexe.h> // BUILDBUILD: added this from shellprv.h
#include "resource.h" // BUILDBUILD: use local resource IDs
#ifdef RegQueryValue
#undef RegQueryValue
#endif
#define RegQueryValue(hkey, pszSubkey, pvValue, pcbSize) SHGetValue(hkey, pszSubkey, NULL, NULL, pvValue, pcbSize)
// BUILDBUILD: add from shsemip.h
#define SIZEOF(a) sizeof(a)
// BUILDBUILD: was from cstrings.h
extern CCHAR c_szNULL[];
#include "openas.h"
#undef HINST_THISDLL
#define HINST_THISDLL (GetThisModulesHandle())
#undef ASSERTNONCRITICAL
#define ASSERTNONCRITICAL ASSERT(! AccessIsExclusive());
#define MZMAGIC ((WORD)'M'+((WORD)'Z'<<8))
#define LEMAGIC ((WORD)'L'+((WORD)'E'<<8))
#define FCC(c0,c1,c2,c3) ((DWORD)(c0)|((DWORD)(c1)<<8)|((DWORD)(c2)<<16)|((DWORD)(c3)<<24))
#define COM_FILE FCC('.', 'c', 'o', 'm')
#define BAT_FILE FCC('.', 'b', 'a', 't')
#define EXE_FILE FCC('.', 'e', 'x', 'e')
#define hinstCabinet GetThisModulesHandle()
BOOL GetClassDescription(HKEY hkClasses, LPCSTR pszClass, LPSTR szDisplayName, int cbDisplayName, UINT uFlags);
/* needed because the NT shell only understands unicode for these
* functions...
*/
/* define the local versions */
extern BOOL lPathIsExeA(LPCSTR);
extern int lShell_GetCachedImageIndexA(LPCSTR, int, UINT);
extern BOOL lPathYetAnotherMakeUniqueNameA(LPSTR,LPCSTR,LPCSTR,LPCSTR);
extern LONG lRegDeleteKeyA(HKEY, LPCSTR);
/***********************************************************
* Needed because under NT, deleting a subkey will fail.
*
* Stolen from the SDK:
* Windows 95: The RegDeleteKey function deletes a key and
* all its descendents.
* Windows NT: The RegDeleteKey function deletes the specified
* key. This function cannot delete a key that has
* subkeys.
**********************************************************/
// On Win95, RegDeleteKey deletes the key and all subkeys. On NT, RegDeleteKey
// fails if there are any subkeys. On NT, we'll make shell code that assumes
// the Win95 behavior work by mapping SHRegDeleteKey to a helper function that
// does the recursive delete.
// The reason we do it here, instead of calling the shell is so that we don't
// have any bogus dynalinks for the X86 version, which must also run on W95.
LONG ShRegDeleteKey(HKEY hKey, LPCSTR lpSubKey)
{
LONG lResult;
HKEY hkSubKey;
DWORD dwIndex;
char szSubKeyName[MAX_PATH + 1];
DWORD cchSubKeyName = ARRAYSIZE(szSubKeyName);
char szClass[MAX_PATH];
DWORD cbClass = ARRAYSIZE(szClass);
DWORD dwDummy1, dwDummy2, dwDummy3, dwDummy4, dwDummy5, dwDummy6;
FILETIME ft;
// Open the subkey so we can enumerate any children
lResult = RegOpenKeyExA(hKey, lpSubKey, 0, KEY_ALL_ACCESS, &hkSubKey);
if (ERROR_SUCCESS == lResult)
{
// I can't just call RegEnumKey with an ever-increasing index, because
// I'm deleting the subkeys as I go, which alters the indices of the
// remaining subkeys in an implementation-dependent way. In order to
// be safe, I have to count backwards while deleting the subkeys.
// Find out how many subkeys there are
lResult = RegQueryInfoKey(hkSubKey,
szClass,
&cbClass,
NULL,
&dwIndex, // The # of subkeys -- all we need
&dwDummy1,
&dwDummy2,
&dwDummy3,
&dwDummy4,
&dwDummy5,
&dwDummy6,
&ft);
if (ERROR_SUCCESS == lResult)
{
// dwIndex is now the count of subkeys, but it needs to be
// zero-based for RegEnumKey, so I'll pre-decrement, rather
// than post-decrement.
while (ERROR_SUCCESS == RegEnumKey(hkSubKey, --dwIndex, szSubKeyName, cchSubKeyName))
{
ShRegDeleteKey(hkSubKey, szSubKeyName);
}
}
// APPCOMPAT
// Issue with shellprv. For some reason someone commented out the definition of SHRegCloseKey
// SHRegCloseKey is not in Win95. Doing an undef here puts it back to RegCloseKey
// Works now on both NT and Win95
//
#undef RegCloseKey
RegCloseKey(hkSubKey);
lResult = RegDeleteKey(hKey, lpSubKey);
}
return lResult;
}
LONG lRegDeleteKeyA(HKEY hKey, LPCSTR lpSubKey)
{
if (RUNNING_NT)
return(ShRegDeleteKey(hKey, lpSubKey));
else
return(RegDeleteKey(hKey, lpSubKey));
}
// in:
// pszPath directory to do this into or full dest path
// if pszShort is NULL
// pszShort file name (short version) if NULL assumes
// pszPath is both path and spec
// pszFileSpec file name (long version)
//
// out:
// pszUniqueName
//
// returns:
// TRUE success, name can be used
BOOL lPathYetAnotherMakeUniqueNameA(LPSTR pszUniqueName,
LPCSTR pszPath,
LPCSTR pszShort,
LPCSTR pszFileSpec)
{
if (RUNNING_NT)
{
LPSTR lpPath,lpShort,lpFileSpec;
WCHAR tmpBuf[MAX_PATH];
WCHAR tmpPath[MAX_PATH];
WCHAR tmpShort[MAX_PATH];
WCHAR tmpFileSpec[MAX_PATH];
BOOL retVal;
if((lpPath = (LPSTR)pszPath)!= NULL)
{
lpPath = (LPSTR)tmpPath;
MultiByteToWideChar(CP_ACP, 0, pszPath, -1, (LPWSTR)lpPath,
ARRAYSIZE(tmpPath));
}
if((lpShort = (LPSTR)pszShort)!= NULL)
{
lpShort = (LPSTR)tmpShort;
MultiByteToWideChar(CP_ACP, 0, pszShort, -1, (LPWSTR)lpShort,
ARRAYSIZE(tmpShort));
}
if((lpFileSpec = (LPSTR)pszFileSpec)!= NULL)
{
lpFileSpec = (LPSTR)tmpFileSpec;
MultiByteToWideChar(CP_ACP, 0, pszFileSpec, -1, (LPWSTR)lpFileSpec,
ARRAYSIZE(tmpFileSpec));
}
MultiByteToWideChar(CP_ACP, 0, pszUniqueName, -1, tmpBuf,
ARRAYSIZE(tmpBuf));
retVal = PathYetAnotherMakeUniqueName(tmpBuf, (LPWSTR)lpPath,
(LPWSTR)lpShort, (LPWSTR)lpFileSpec); // (LPWSTR) so it builds, but works downlevel
if(retVal)
WideCharToMultiByte(CP_ACP, 0, tmpBuf, -1,
pszUniqueName, ARRAYSIZE(tmpBuf),
NULL, NULL);
return(retVal);
}
else
return(PathYetAnotherMakeUniqueName((LPWSTR)pszUniqueName, (LPWSTR)pszPath,
(LPWSTR)pszShort, (LPWSTR)pszFileSpec)); // (LPWSTR) so it builds, but works downlevel
}
////////////////////////////////////////////////////////////////
//
// in:
// pszIconPath file to get icon from (eg. cabinet.exe)
// iIconIndex icon index in pszIconPath to get
// uIconFlags GIL_ values indicating simulate doc icon, etc.
int lShell_GetCachedImageIndexA(LPCSTR pszIconPath, int iIconIndex, UINT uIconFlags)
{
if (RUNNING_NT)
{
WCHAR uPath[MAX_PATH];
MultiByteToWideChar(CP_ACP, 0, pszIconPath, -1, uPath,
ARRAYSIZE(uPath));
return Shell_GetCachedImageIndex(uPath, iIconIndex, uIconFlags);
}
else
return Shell_GetCachedImageIndex((LPWSTR)pszIconPath, iIconIndex, uIconFlags); // (LPWSTR) so it builds, but works downlevel
}
// determine if a path is a program by looking at the extension
//
BOOL lPathIsExeA(LPCSTR szFile)
{
if (RUNNING_NT)
{
WCHAR uPath[MAX_PATH];
MultiByteToWideChar(CP_ACP, 0, szFile, -1, uPath,
ARRAYSIZE(uPath));
return (PathIsExe(uPath));
}
else
return PathIsExe((LPWSTR)szFile); // (LPWSTR) so it builds, but works downlevel
}
/*
* BUILDBUILD: Replacements for shell32.dll critical section functions for
* shell32.dll!hash.c.
*/
void Shell_EnterCriticalSection(void)
{
BeginExclusiveAccess();
return;
}
void Shell_LeaveCriticalSection(void)
{
EndExclusiveAccess();
return;
}
#define DATA_SEG_READ_ONLY ".text"
#pragma data_seg(DATA_SEG_READ_ONLY)
/*
* They meant to use const char arrays here, rather than char
* const arrays. Arrays are implicitly const. But this is how these array are
* declared in shell32.dll!cstrings.h.
*/
char const c_szPercentOne[] = "%1";
char const c_szPercentl[] = "%l";
char const c_szPercentL[] = "%L";
char const c_szRunDll[] = "rundll32.exe";
char const c_szShellOpenCmd[] = "shell\\open\\command";
char const c_szShellOpenDDEExec[] = "shell\\open\\ddeexec";
char const c_szSlashCommand[] = "\\command";
char const c_szSlashDDEExec[] = "\\ddeexec";
char const c_szStar[] = "*";
#pragma data_seg()
char g_szFileTypeName[32] = " "; // First char is blank such that can append...
/* BUILDBUILD: LVUtil_GetLParam() swiped from shell32.dll!lvutil.c. */
//
// Note that it returns NULL, if iItem is -1.
//
LPARAM PASCAL LVUtil_GetLParam(HWND hwndLV, int i)
{
LV_ITEM item;
item.mask = LVIF_PARAM;
item.iItem = i;
item.iSubItem = 0;
item.lParam = 0;
if (i != -1)
{
ListView_GetItem(hwndLV, &item);
}
return item.lParam;
}
/* BUILDBUILD: App_IsLFNAware() swiped from shell32.dll!shlexec.c. */
//----------------------------------------------------------------------------
#define PEMAGIC ((WORD)'P'+((WORD)'E'<<8))
#if 0
/* BUILDBUILD: NEMAGIC is defined in newexe.h, #included for GetExeType(). */
#define NEMAGIC ((WORD)'N'+((WORD)'E'<<8))
#endif
//----------------------------------------------------------------------------
// Returns TRUE is app is LFN aware.
// NB This simply assumes all Win4.0 and all Win32 apps are LFN aware.
BOOL App_IsLFNAware(LPCSTR pszFile)
{
DWORD dw;
ASSERT(pszFile);
ASSERT(*pszFile);
// Assume Win 4.0 apps and Win32 apps are LFN aware.
dw = GetExeType(pszFile);
// DebugMsg(DM_TRACE, "s.aila: %s %s %x", lpszFile, szFile, dw);
if ((LOWORD(dw) == PEMAGIC) || ((LOWORD(dw) == NEMAGIC) && (HIWORD(dw) >= 0x0400)))
{
return TRUE;
}
else
{
return FALSE;
}
}
/* BUILDBUILD: SendMessageD() swiped from shell32.dll!init.c. */
#ifdef DEBUG
LRESULT
WINAPI
SendMessageD(
HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam)
{
ASSERTNONCRITICAL;
return SendMessageA(hWnd, Msg, wParam, lParam);
}
#endif // DEBUG
/* BUILDBUILD: HasExtension() swiped from shell32.dll!extract.c. */
DWORD HasExtension(LPCSTR pszPath)
{
LPCSTR p = PathFindExtension(pszPath);
if (*p == '.')
return *((UNALIGNED DWORD *)p) | 0x20202000; // make lower case
else
return 0;
}
/* BUILDBUILD: GetExeType() swiped from shell32.dll!extract.c. */
/****************************************************************************
* GetExeType - get the EXE type of the passed file (DOS, Win16, Win32)
*
* returns:
* 0 = not a exe of any type.
*
* if a windows app
* LOWORD = NE or PE
* HIWORD = windows version 3.0, 3.5, 4.0
*
* if a DOS app (or a .com or batch file)
* LOWORD = MZ
* HIWORD = 0
*
* if a Win32 console app
* LOWORD = PE
* HIWORD = 0
*
* APPCOMPAT this is so similar to the Win32 API GetBinaryType() too bad Win95
* kernel does not support it.
*
****************************************************************************/
DWORD WINAPI GetExeType(LPCSTR szFile)
{
HANDLE fh;
DWORD dw;
struct exe_hdr exehdr;
struct new_exe newexe;
FILETIME ftAccess;
DWORD dwRead;
//
// check for special extensions, and fail quick
//
switch (HasExtension(szFile))
{
case COM_FILE:
case BAT_FILE:
return MAKELONG(MZMAGIC, 0); // DOS exe
case EXE_FILE: // we need to open it.
break;
default:
return 0; // not a exe, or if it is we dont care
}
newexe.ne_expver = 0;
fh = CreateFile(szFile, GENERIC_READ | FILE_WRITE_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE,
0, OPEN_EXISTING, 0, 0);
if (fh == INVALID_HANDLE_VALUE)
{
return 0;
}
// preserve the access time
if (GetFileTime(fh, NULL, &ftAccess, NULL))
SetFileTime(fh, NULL, &ftAccess, NULL);
if (!ReadFile(fh, &exehdr, sizeof(exehdr), &dwRead, NULL) ||
(dwRead != sizeof(exehdr)))
goto error;
if (exehdr.e_magic != EMAGIC)
goto error;
SetFilePointer(fh, exehdr.e_lfanew, NULL, FILE_BEGIN);
ReadFile(fh,&newexe, sizeof(newexe), &dwRead, NULL);
if (newexe.ne_magic == PEMAGIC)
{
// read the SubsystemVersion
SetFilePointer(fh, exehdr.e_lfanew+18*4, NULL, FILE_BEGIN);
ReadFile(fh,&dw,4, &dwRead, NULL);
newexe.ne_expver = LOBYTE(LOWORD(dw)) << 8 | LOBYTE(HIWORD(dw));
// read the Subsystem
SetFilePointer(fh, exehdr.e_lfanew+23*4, NULL, FILE_BEGIN);
ReadFile(fh,&dw,4, &dwRead, NULL);
// if it is not a Win32 GUI app return a version of 0
if (LOWORD(dw) != 2) // IMAGE_SUBSYSTEM_WINDOWS_GUI
newexe.ne_expver = 0;
goto exit;
}
else if (newexe.ne_magic == LEMAGIC)
{
newexe.ne_magic = MZMAGIC; // just a DOS exe
newexe.ne_expver = 0;
}
else if (newexe.ne_magic == NEMAGIC)
{
//
// we found a 'NE' it still might not be a windows
// app, it could be.....
//
// a OS/2 app ne_exetyp==NE_OS2
// a DOS4 app ne_exetyp==NE_DOS4
// a VxD ne_exetyp==DEV386
//
// only treat it as a Windows app if the exetype
// is NE_WINDOWS or NE_UNKNOWN
//
if (newexe.ne_exetyp != NE_WINDOWS && newexe.ne_exetyp != NE_UNKNOWN)
{
newexe.ne_magic = MZMAGIC; // just a DOS exe
newexe.ne_expver = 0;
}
//
// if could also have a bogus expected windows version
// (treat 0 as invalid)
//
if (newexe.ne_expver == 0)
{
newexe.ne_magic = MZMAGIC; // just a DOS exe
newexe.ne_expver = 0;
}
}
else // if (newexe.ne_magic != NEMAGIC)
{
newexe.ne_magic = MZMAGIC; // just a DOS exe
newexe.ne_expver = 0;
}
exit:
CloseHandle(fh);
return MAKELONG(newexe.ne_magic, newexe.ne_expver);
error:
CloseHandle(fh);
return 0;
}
/******************************************************************************
Original Shell32.dll code starts here.
******************************************************************************/
#if 0
/* BUILDBUILD: Remove old headers. */
#include "..\..\inc\help.h"
#include "views.h"
#include "ids.h"
#include "lvutil.h"
#endif
// REARCHITECT: duplicate strings as in cstrings.c
#pragma data_seg(".text", "CODE")
char const c_szSSlashS[] = "%s\\%s";
#pragma data_seg()
extern char g_szFileTypeName[]; // used to build type name...
extern BOOL App_IsLFNAware(LPCSTR pszFile);
void _GenerateAssociateNotify(LPSTR pszExt)
{
char szFakePath[MAX_PATH];
LPITEMIDLIST pidl;
//
// This is a real hack, but for now we generate an idlist that looks
// something like: C:\*.ext which is the extension for the IDList.
// We use the simple IDList as to not hit the disk...
//
// All I do is make an ANSI string, and then jam the unicode
// version into the skinny-char buffer. Saves on stack.
if (RUNNING_NT)
{
char tmpBuf[20];
lstrcpy(tmpBuf, "c:\\");
lstrcat(tmpBuf, c_szStar);
lstrcat(tmpBuf, pszExt);
MultiByteToWideChar(CP_ACP, 0, tmpBuf, -1, (LPWSTR)szFakePath,
sizeof(szFakePath)/sizeof(WCHAR));
}
else
{
PathBuildRoot(szFakePath, 2); // (c:\)
lstrcat(szFakePath, c_szStar);
lstrcat(szFakePath, pszExt);
}
pidl = SHSimpleIDListFromPath((LPWSTR)szFakePath); // (LPWSTR) so it builds, but works downlevel
// Now call off to the notify function.
SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, pidl, NULL);
ILFree(pidl);
}
// Given a class key returns the shell\open\command string in szValue
// and the number of chars copied in cbMaxValue. cbMaxValue should
// be initialised to the max siz eof szValue.
void GetCmdLine(LPCSTR szKey, LPSTR szValue, LONG cbValue)
{
char szTemp[MAX_PATH+40]; // Leave room for both extension plus junk on at end...
wsprintf(szTemp, c_szSSlashS, szKey, c_szShellOpenCmd);
szValue[0] = 0;
RegQueryValue(HKEY_CLASSES_ROOT, szTemp, szValue, &cbValue);
}
// uFlags GCD_ flags from GetClassDescription uFlags
void FillListWithClasses(HWND hwnd, BOOL fComboBox, UINT uFlags)
{
int i;
char szClass[CCH_KEYMAX];
char szDisplayName[CCH_KEYMAX];
LONG lcb;
SendMessage(hwnd, fComboBox ? CB_RESETCONTENT : LB_RESETCONTENT, 0, 0L);
if (uFlags & GCD_MUSTHAVEEXTASSOC)
{
char szExt[CCH_KEYMAX];
// The caller stated that they only want those classes that
// have have at least one extension associated with it.
//
for (i = 0; RegEnumKey(HKEY_CLASSES_ROOT, i, szClass, sizeof(szClass)) == ERROR_SUCCESS; i++)
{
// Is this an extension
if (szClass[0] != '.')
continue; // go process the next one...
// Get the class name
lstrcpy(szExt, szClass);
lcb = sizeof(szClass);
if ((RegQueryValue(HKEY_CLASSES_ROOT, szExt, szClass, &lcb) != ERROR_SUCCESS) || (lcb == 0))
continue; // Again we are not interested.
// use uFlags passed in to filter
if (GetClassDescription(HKEY_CLASSES_ROOT, szClass, szDisplayName, sizeof(szDisplayName), uFlags))
{
int iItem;
// Now make sure it is not already in the list...
if ((int)SendMessage(hwnd, fComboBox ? CB_FINDSTRINGEXACT : LB_FINDSTRINGEXACT,
(WPARAM)-1, (LPARAM)(LPSTR)szDisplayName) >= 0)
continue; // allready in the list.
// sorted
iItem = (int)SendMessage(hwnd, fComboBox ? CB_ADDSTRING : LB_ADDSTRING,
0, (LPARAM)(LPSTR)szDisplayName);
if (iItem >= 0)
SendMessage(hwnd, fComboBox ? CB_SETITEMDATA : LB_SETITEMDATA, iItem, (LPARAM)AddHashItem(NULL, szClass));
}
}
}
else
{
for (i = 0; RegEnumKey(HKEY_CLASSES_ROOT, i, szClass, sizeof(szClass)) == ERROR_SUCCESS; i++)
{
// use uFlags passed in to filter
if (GetClassDescription(HKEY_CLASSES_ROOT, szClass, szDisplayName, sizeof(szDisplayName), uFlags))
{
// sorted
int iItem = (int)SendMessage(hwnd, fComboBox ? CB_ADDSTRING : LB_ADDSTRING,
0, (LPARAM)(LPSTR)szDisplayName);
if (iItem >= 0)
SendMessage(hwnd, fComboBox ? CB_SETITEMDATA : LB_SETITEMDATA, iItem, (LPARAM)AddHashItem(NULL, szClass));
}
}
}
}
// get the displayable name for file types "classes"
//
//
// uFlags:
// GCD_MUSTHAVEOPENCMD only returns things with open verbs
// GCD_ADDEXETODISPNAME append the name of the ext that is in the open cmd
// (GCD_MUSTHAVEOPENCMD)
// GCD_ALLOWPSUDEOCLASSES return psudeo classes, those with stuff haning
// off the .ext key
BOOL GetClassDescription(HKEY hkClasses, LPCSTR pszClass, LPSTR szDisplayName, int cbDisplayName, UINT uFlags)
{
char szExe[MAX_PATH];
char szClass[CCH_KEYMAX];
LPSTR pszExeFile;
LONG lcb;
// Skip things that aren't classes (extensions).
if (pszClass[0] == '.')
{
if (uFlags & GCD_ALLOWPSUDEOCLASSES)
{
lcb = sizeof(szClass);
if ((RegQueryValue(hkClasses, pszClass, szClass, &lcb) != ERROR_SUCCESS) || (lcb == 0))
{
// look for .ext\shel\open\command directly (hard wired association)
// if this extenstion does not name a real class
GetCmdLine(pszClass, szExe, sizeof(szExe));
if (szExe[0]) {
lstrcpyn(szDisplayName, PathFindFileName(szExe), cbDisplayName);
return TRUE;
}
return FALSE;
}
pszClass = szClass;
}
else
{
return FALSE; // don't return psudeo class
}
}
// REVIEW: we should really special case the OLE junk here. if pszClass is
// CLSID, Interface, TypeLib, etc we should skip it
// REVIEW: we really need to verify that some extension points at this type to verfy
// that it is valid. perhaps the existance of a "shell" key is enough.
// get the classes displayable name
lcb = cbDisplayName;
if (RegQueryValue(hkClasses, pszClass, szDisplayName, &lcb) != ERROR_SUCCESS || (lcb < 2))
return FALSE;
if (uFlags & GCD_MUSTHAVEOPENCMD)
{
// verify that it has an open command
GetCmdLine(pszClass, szExe, sizeof(szExe));
if (!szExe[0])
return FALSE;
// WARNING: currently this is dead functionallity
if (uFlags & GCD_ADDEXETODISPNAME)
{
PathRemoveArgs(szExe);
// eliminate per instance type things (programs, pif, etc)
// Skip things that aren't relevant ot the shell.
if (szExe[0] == '%')
return FALSE;
// skip things with per-instance type associations
pszExeFile = PathFindFileName(szExe);
if (lstrlen(szDisplayName) + lstrlen(pszExeFile) + 2 < cbDisplayName)
{
#pragma data_seg(".text", "CODE")
wsprintf(szDisplayName + lstrlen(szDisplayName), " (%s)", pszExeFile);
#pragma data_seg()
}
}
}
return TRUE;
}
void DeleteListAttoms(HWND hwnd, BOOL fComboBox)
{
int cItems;
PHASHITEM phiClass;
int iGetDataMsg;
iGetDataMsg = fComboBox ? CB_GETITEMDATA : LB_GETITEMDATA;
cItems = (int)SendMessage(hwnd, fComboBox ? CB_GETCOUNT : LB_GETCOUNT, 0, 0) - 1;
/* clean out them atoms except for "(none)".
*/
for (; cItems >= 0; cItems--)
{
phiClass = (PHASHITEM)SendMessage(hwnd, iGetDataMsg, cItems, 0L);
if (phiClass != (PHASHITEM)LB_ERR && phiClass)
DeleteHashItem(NULL, phiClass);
}
}
// BEGIN new stuff
typedef struct { // oad
// params
HWND hwnd;
POPENASINFO poainfo;
// local data
int idDlg;
HWND hDlg;
HWND hwndList;
LPSTR lpszExt;
LPCSTR lpcszClass;
HRESULT hr;
char szTypeName[CCH_KEYMAX]; // type name
char szDescription[CCH_KEYMAX]; // type description
} OPENAS_DATA, *POPENAS_DATA;
typedef struct {
UINT bHasQuote; // Did we find a quote around param? "%1"
char szApp[MAX_PATH+2]; // May need room for quotes
} APPINFO;
#define HASQUOTE_NO 0
#define HASQUOTE_MAYBE 1
#define HASQUOTE_YES 3
BOOL QuotesAroundArg(PCSTR pcszCmdLine)
{
BOOL bQuotes = FALSE;
PCSTR pcsz;
/* Is there a %1, %l, or %L on the command line? */
if ((pcsz = StrStr(pcszCmdLine, c_szPercentOne)) != NULL ||
(pcsz = StrStr(pcszCmdLine, c_szPercentl)) != NULL ||
(pcsz = StrStr(pcszCmdLine, c_szPercentL)) != NULL)
{
/* Yes. Is it preceded by double quotes? */
if (*(pcsz - 1) == '"')
/* Yes. */
bQuotes = TRUE;
}
return(bQuotes);
}
void FillListWithApps(HWND hwndList)
{
int i, iMax;
char szClass[CCH_KEYMAX];
char szKey[CCH_KEYMAX];
char szValue[MAX_PATH];
APPINFO *paiLast;
LV_ITEM item;
int iLast;
BOOL fLastExists = FALSE;
for (i = 0; RegEnumKey(HKEY_CLASSES_ROOT, i, szClass, sizeof(szClass)) == ERROR_SUCCESS; i++)
{
LONG lTmp;
wsprintf(szKey, c_szSSlashS, szClass, c_szShellOpenCmd);
lTmp = sizeof(szValue);
if (RegQueryValue(HKEY_CLASSES_ROOT, szKey, szValue, &lTmp) == ERROR_SUCCESS)
{
// filter out stuff we know is bogus
// strings that start with: %1, "%1"
// strings that contain: rundll
//
if ((szValue[0] != '%') &&
((szValue[0] != '"') || (szValue[1] != '%')) &&
(StrStr(szValue, c_szRunDll) == NULL))
{
APPINFO *pai = (APPINFO *)LocalAlloc(LPTR, sizeof(APPINFO));
if (pai)
{
if (QuotesAroundArg(szValue))
pai->bHasQuote = HASQUOTE_YES;
else
{
char szDDEExecValue[MAX_PATH];
wsprintf(szKey, c_szSSlashS, szClass,
c_szShellOpenDDEExec);
lTmp = sizeof(szDDEExecValue);
if (RegQueryValue(HKEY_CLASSES_ROOT, szKey,
szDDEExecValue, &lTmp)
== ERROR_SUCCESS)
{
if (QuotesAroundArg(szDDEExecValue))
pai->bHasQuote = HASQUOTE_YES;
}
}
PathRemoveArgs(szValue);
lstrcpy(pai->szApp, szValue);
item.mask = LVIF_TEXT|LVIF_IMAGE|LVIF_PARAM;
item.iItem = 0x7FFF;
item.iSubItem = 0;
item.state = 0;
item.iImage = I_IMAGECALLBACK;
PathRemoveExtension(szValue);
item.pszText = PathFindFileName(szValue);
item.lParam = (LPARAM)pai;
ListView_InsertItem(hwndList, &item);
}
}
}
}
// punt dups
ListView_SortItems(hwndList, NULL, 0);
paiLast = NULL;
// szKey will hold the lpszLast's display name
for (i = 0, iMax = ListView_GetItemCount(hwndList); i < iMax; i++)
{
APPINFO *pai;
item.mask = LVIF_TEXT | LVIF_PARAM;
item.iItem = i;
item.iSubItem = 0;
item.pszText = szValue;
item.cchTextMax = sizeof(szValue);
// get the text string
ListView_GetItem(hwndList, &item);
pai = (APPINFO *)item.lParam;
if (paiLast && (!lstrcmpi(szKey, szValue))) {
int iDelete = i;
// if they are different in path, delete the one that doesn't exit (or the new one if they both do)
if (lstrcmpi(paiLast->szApp, pai->szApp)) {
if (!fLastExists && !(fLastExists = PathFileExists(pai->szApp))) {
if (paiLast->bHasQuote > pai->bHasQuote)
pai->bHasQuote = paiLast->bHasQuote;
iDelete = iLast;
}
}
// Will assume that if either item has quote set that it will work...
if (pai->bHasQuote > paiLast->bHasQuote)
paiLast->bHasQuote =pai->bHasQuote;
ListView_DeleteItem(hwndList, iDelete);
i--; iMax--;
// we deleted the iLast, we need to set a new iLast
if (iDelete == iLast)
goto NewLastExe;
} else {
NewLastExe:
iLast = i;
paiLast = pai;
lstrcpy(szKey, szValue);
fLastExists = TRUE;
}
}
// Lets set the focus to first item, but not the focus as some users
// have made the mistake and type in the name and hit return and it
// runs the first guy in the list which in the current cases tries to
// run the backup app...
ListView_SetItemState(hwndList, 0, LVNI_FOCUSED, LVNI_FOCUSED | LVNI_SELECTED);
SetFocus(hwndList);
}
void _InitOpenAsDlg(POPENAS_DATA poad)
{
char szFormat[200];
char szFileName[MAX_PATH];
char szTemp[MAX_PATH + sizeof(szFormat)];
BOOL fDisableAssociate;
HIMAGELIST himlLarge = NULL;
HIMAGELIST himlSmall = NULL;
LV_COLUMN col = {LVCF_FMT | LVCF_WIDTH, LVCFMT_LEFT};
RECT rc;
// Don't let the file name go beyond the width of one line...
GetDlgItemText(poad->hDlg, IDD_TEXT, szFormat, sizeof(szFormat));
lstrcpy(szFileName, PathFindFileName(poad->poainfo->pcszFile));
GetClientRect(GetDlgItem(poad->hDlg, IDD_TEXT), &rc);
PathCompactPath(NULL, szFileName, rc.right - 4 * GetSystemMetrics(SM_CXBORDER));
wsprintf(szTemp, szFormat, szFileName);
SetDlgItemText(poad->hDlg, IDD_TEXT, szTemp);
// Don't allow associations to be made for things we consider exes...
fDisableAssociate = (! (poad->poainfo->dwInFlags & OPENASINFO_FL_ALLOW_REGISTRATION) ||
lPathIsExeA(poad->poainfo->pcszFile));
if (poad->idDlg == DLG_OPENAS_NOTYPE) {
GetDlgItemText(poad->hDlg, IDD_DESCRIPTIONTEXT, szFormat, sizeof(szFormat));
wsprintf(szTemp, szFormat, poad->lpcszClass);
SetDlgItemText(poad->hDlg, IDD_DESCRIPTIONTEXT, szTemp);
// Default to Set the association here if we do not know what
// the file is...
if (!fDisableAssociate)
CheckDlgButton(poad->hDlg, IDD_MAKEASSOC, TRUE);
}
if (fDisableAssociate)
EnableWindow(GetDlgItem(poad->hDlg, IDD_MAKEASSOC), FALSE);
poad->hwndList = GetDlgItem(poad->hDlg, IDD_APPLIST);
Shell_GetImageLists(&himlLarge, &himlSmall);
if(himlLarge != NULL)
ListView_SetImageList(poad->hwndList, himlLarge, LVSIL_NORMAL);
if(himlSmall != NULL)
ListView_SetImageList(poad->hwndList, himlSmall, LVSIL_SMALL);
SetWindowLong(poad->hwndList, GWL_EXSTYLE,
GetWindowLong(poad->hwndList, GWL_EXSTYLE) | WS_EX_CLIENTEDGE);
GetClientRect(poad->hwndList, &rc);
col.cx = rc.right - GetSystemMetrics(SM_CXVSCROLL)
- 4 * GetSystemMetrics(SM_CXEDGE);
ListView_InsertColumn(poad->hwndList, 0, &col);
FillListWithApps(poad->hwndList);
// and initialize the OK button
EnableWindow(GetDlgItem(poad->hDlg, IDOK),
(ListView_GetNextItem(poad->hwndList, -1, LVNI_SELECTED) != -1));
}
void RunAs(POPENAS_DATA poad)
{
SHELLEXECUTEINFO ExecInfo;
// If this run created a new type we should use it, otherwise we should
// construct a command using the exe that we selected...
if (*poad->lpszExt && IsDlgButtonChecked(poad->hDlg, IDD_MAKEASSOC))
{
FillExecInfo(ExecInfo, poad->hwnd, NULL, poad->poainfo->pcszFile, NULL, NULL, SW_NORMAL);
}
else
{
char szApp[MAX_PATH];
char szQuotedFile[MAX_PATH+2];
APPINFO *pai;
int iItemFocus = ListView_GetNextItem(poad->hwndList, -1, LVNI_SELECTED);
pai = (APPINFO *)LVUtil_GetLParam(poad->hwndList, iItemFocus);
lstrcpy(szQuotedFile, poad->poainfo->pcszFile);
lstrcpy(szApp, pai->szApp);
PathUnquoteSpaces(szApp);
// Try to intellegently quote blanks or not...
if (!App_IsLFNAware(szApp))
{
// We better also make sure that this a short path name
// pass off to the application...
char tmpBuf[MAX_PATH];
GetShortPathName(szQuotedFile, tmpBuf, SIZECHARS(tmpBuf));
lstrcpy(szQuotedFile, tmpBuf);
}
else
{
// Either maybe or yes is we should quote
if (pai->bHasQuote)
PathQuoteSpaces(szQuotedFile);
}
FillExecInfo(ExecInfo, poad->hwnd, NULL, szApp, szQuotedFile, NULL, SW_NORMAL);
}
ShellExecuteEx(&ExecInfo);
}
void OpenAsOther(POPENAS_DATA poad)
{
char szText[MAX_PATH];
BOOL retval;
#if 0
/*
* BUILDBUILD: There is no IDD_COMMAND control in DLG_OPENAS or
* DLG_OPENAS_NOTYPE.
*/
GetDlgItemText(poad->hDlg, IDD_COMMAND, szText, sizeof(szText));
#else
*szText = '\0\0';
#endif
// now it will work on NT: unicode
// do a file open browse
if (RUNNING_NT)
{
WCHAR szuPath[MAX_PATH];
WCHAR szuExe[16];
WCHAR szuFilters[MAX_PATH];
WCHAR szuTitle[80];
LPWSTR psz;
szuPath[0] = szuTitle[0] = szuExe[0] = szuFilters[0]= 0;
MLLoadStringW(IDS_OPENAS, szuTitle, 80);
MLLoadStringW(IDS_EXE, szuExe, 16);
MLLoadStringW(IDS_PROGRAMSFILTER, szuFilters, MAX_PATH);
/* hack up the array... */
psz = szuFilters;
while (*psz)
{
if (*psz == (WCHAR)('#'))
*psz = (WCHAR)('\0');
psz++;
}
retval = GetFileNameFromBrowse(poad->hDlg, szuPath,
ARRAYSIZE(szuPath), NULL, szuExe,
szuFilters, szuTitle);
/* make certain we convert back to ANSI chars! */
if (retval)
WideCharToMultiByte(CP_ACP,0,szuPath,-1,szText,
ARRAYSIZE(szuPath),NULL,NULL);
}
else
{
CHAR szExe[16];
CHAR szFilters[MAX_PATH];
CHAR szTitle[80];
LPSTR psz;
szTitle[0] = szExe[0] = szFilters[0]= 0;
MLLoadStringA(IDS_OPENAS, szTitle, 80);
MLLoadStringA(IDS_EXE, szExe, 16);
MLLoadStringA(IDS_PROGRAMSFILTER, szFilters, MAX_PATH);
/* hack up the array... */
psz = szFilters;
while (*psz)
{
if (*psz == (CHAR)('#'))
*psz = (CHAR)('\0');
psz++;
}
retval = GetFileNameFromBrowse(poad->hDlg, (LPWSTR)szText,
sizeof(szText), NULL,
(LPWSTR)szExe, (LPWSTR)szFilters, (LPWSTR)szTitle); // (LPWSTR) so it builds, but works downlevel
}
if (retval)
{
// then add it to the list view and select it.
APPINFO *pai = (APPINFO *)LocalAlloc(LPTR, sizeof(APPINFO));
if (pai)
{
LV_ITEM item;
int i;
int iItem;
APPINFO *paiT;
pai->bHasQuote = HASQUOTE_MAYBE;
lstrcpy(pai->szApp, szText);
PathQuoteSpaces(pai->szApp);
item.mask = LVIF_TEXT|LVIF_IMAGE|LVIF_PARAM;
item.iItem = 0x7FFF;
item.iSubItem = 0;
item.state = 0;
item.iImage = I_IMAGECALLBACK;
PathRemoveExtension(szText);
item.pszText = PathFindFileName(szText);
item.lParam = (LPARAM)pai;
i = ListView_InsertItem(poad->hwndList, &item);
ListView_SetItemState(poad->hwndList, i, LVNI_SELECTED | LVNI_FOCUSED, LVNI_SELECTED | LVNI_FOCUSED);
ListView_EnsureVisible(poad->hwndList, i, FALSE);
SetFocus(poad->hwndList);
// We also want to see if we find another entry in the listview for the
// application. We do this such that we can see if the app supports
// quotes or not.
for (iItem = ListView_GetItemCount(poad->hwndList) - 1; iItem >= 0; iItem--)
{
if (iItem == i)
continue;
item.mask = LVIF_PARAM;
item.iItem = iItem;
item.iSubItem = 0;
ListView_GetItem(poad->hwndList, &item);
paiT = (APPINFO *)item.lParam;
if (lstrcmpi(pai->szApp, paiT->szApp) == 0)
{
pai->bHasQuote = paiT->bHasQuote;
break;
}
}
}
}
}
// return true if ok to continue
BOOL OpenAsMakeAssociation(POPENAS_DATA poad)
{
UINT err;
// See if we should make an association or not...
if (!IsDlgButtonChecked(poad->hDlg, IDD_MAKEASSOC))
return(TRUE);
if (poad->idDlg == DLG_OPENAS_NOTYPE) {
GetDlgItemText(poad->hDlg, IDD_DESCRIPTION, poad->szDescription, sizeof poad->szDescription);
if (*poad->szDescription == '\0') {
// Another place to make sure Ivans tests don't catch...
/* BUILDBUILD: Load IDS_FILETYPENAME here. */
if (lstrlen(g_szFileTypeName) <2)
{
MLLoadStringA(IDS_FILETYPENAME,
g_szFileTypeName+1, sizeof(g_szFileTypeName)-1);
}
lstrcpyn(poad->szDescription, AnsiNext(poad->lpszExt),
ARRAYSIZE(poad->szDescription) - lstrlen(g_szFileTypeName) -1);
AnsiUpper(poad->szDescription);
// Likewise we add a blank at start for appending for FOO Files..
lstrcat(poad->szDescription, g_szFileTypeName);
}
#pragma data_seg(".text", "CODE")
lstrcpyn(poad->szTypeName, poad->lpszExt+1, sizeof(poad->szTypeName)
- sizeof("_auto_file"));
lstrcat(poad->szTypeName, "_auto_file");
#pragma data_seg()
err = RegSetValueA(HKEY_CLASSES_ROOT, poad->lpszExt, REG_SZ, poad->szTypeName, 0L);
err |= RegSetValueA(HKEY_CLASSES_ROOT, poad->szTypeName, REG_SZ, poad->szDescription, 0L);
ASSERT(err == ERROR_SUCCESS);
if (err != ERROR_SUCCESS)
{
MessageBeep(MB_ICONEXCLAMATION);
return(FALSE);
}
}
if (*poad->lpszExt) {
char szTemp[MAX_PATH];
char szCommand[MAX_PATH + 10];
int iItemFocus = ListView_GetNextItem(poad->hwndList, -1, LVNI_FOCUSED);
APPINFO *pai = (APPINFO *)LVUtil_GetLParam(poad->hwndList, iItemFocus);
#pragma data_seg(".text", "CODE")
// We need to set the open commands value to empty to take care of cases
// that have something like: open=&Merge
wsprintf(szTemp, "%s\\shell\\open", poad->szTypeName);
err = RegSetValueA(HKEY_CLASSES_ROOT, szTemp, REG_SZ, c_szNULL, 0L);
lstrcat(szTemp, c_szSlashCommand);
if ((pai->bHasQuote == HASQUOTE_YES) ||
((pai->bHasQuote == HASQUOTE_MAYBE) && App_IsLFNAware(pai->szApp)))
wsprintf(szCommand, "%s \"%%1\"", pai->szApp);
else
wsprintf(szCommand, "%s %%1", pai->szApp);
err = RegSetValueA(HKEY_CLASSES_ROOT, szTemp, REG_SZ, szCommand, 0L);
ASSERT(err == ERROR_SUCCESS);
if (err != ERROR_SUCCESS)
{
MessageBeep(MB_ICONEXCLAMATION);
return(FALSE);
}
// Need to delete any ddeexec information that might also exist...
PathRemoveFileSpec(szTemp); // Remove the command (last component)
lstrcat(szTemp, c_szSlashDDEExec);
lRegDeleteKeyA(HKEY_CLASSES_ROOT, szTemp);
#pragma data_seg()
// notify views
_GenerateAssociateNotify(poad->lpszExt);
}
return TRUE;
}
#pragma data_seg(DATASEG_READONLY)
const static DWORD aOpenAsHelpIDs[] = { // Context Help IDs
IDD_TEXT, IDH_FCAB_OPENAS_DESCRIPTION,
IDD_DESCRIPTIONTEXT, IDH_FCAB_OPENAS_DESCRIPTION,
IDD_DESCRIPTION, IDH_FCAB_OPENAS_DESCRIPTION,
IDD_APPLIST, IDH_FCAB_OPENAS_APPLIST,
IDD_MAKEASSOC, IDH_FCAB_OPENAS_MAKEASSOC,
IDD_OTHER, IDH_FCAB_OPENAS_OTHER,
0, 0
};
#pragma data_seg()
INT_PTR CALLBACK OpenAsDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
{
POPENAS_DATA poad = (POPENAS_DATA)GetWindowLongPtr(hDlg, DWLP_USER);
APPINFO *pai;
int iItemFocus;
switch (wMsg) {
case WM_INITDIALOG:
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
poad = (POPENAS_DATA)lParam;
poad->hDlg = hDlg;
_InitOpenAsDlg(poad);
break;
case WM_HELP:
SHWinHelpOnDemandWrap((HWND)((LPHELPINFO) lParam)->hItemHandle, NULL,
HELP_WM_HELP, (DWORD_PTR)(LPSTR) aOpenAsHelpIDs);
break;
case WM_CONTEXTMENU:
if ((int)SendMessage(hDlg, WM_NCHITTEST, 0, lParam) != HTCLIENT)
return FALSE; // don't process it
SHWinHelpOnDemandWrap((HWND) wParam, NULL, HELP_CONTEXTMENU,
(DWORD_PTR)(LPVOID)aOpenAsHelpIDs);
break;
case WM_NOTIFY:
switch (((LPNMHDR)lParam)->code)
{
case LVN_GETDISPINFO:
{
#define pdi ((LV_DISPINFO *)lParam)
char szApp[MAX_PATH];
APPINFO *pai = (APPINFO *)pdi->item.lParam;
lstrcpy(szApp, pai->szApp);
PathUnquoteSpaces(szApp);
pdi->item.iImage = lShell_GetCachedImageIndexA(szApp, 0, 0);
if (pdi->item.iImage == -1)
pdi->item.iImage = II_APPLICATION;
break;
#undef pdi
}
case LVN_DELETEITEM:
LocalFree((HLOCAL)((NM_LISTVIEW *)lParam)->lParam);
break;
case LVN_ITEMCHANGED:
EnableWindow(GetDlgItem(hDlg, IDOK),
(ListView_GetNextItem(poad->hwndList, -1, LVNI_SELECTED) != -1));
break;
case NM_DBLCLK:
if (IsWindowEnabled(GetDlgItem(hDlg, IDOK)))
PostMessage(hDlg, WM_COMMAND, GET_WM_COMMAND_MPS(IDOK, hDlg, 0));
break;
}
break;
case WM_COMMAND:
ASSERT(poad);
switch (GET_WM_COMMAND_ID(wParam, lParam)) {
case IDD_OTHER:
OpenAsOther(poad);
break;
case IDOK:
/* Register association if requested. */
// The NT URL has this commented out...
if (//(poad->poainfo->dwInFlags & OPENASINFO_FL_REGISTER_EXT) &&
! OpenAsMakeAssociation(poad))
break;
/* Copy name of associated application. */
iItemFocus = ListView_GetNextItem(poad->hwndList, -1, LVNI_SELECTED);
pai = (APPINFO *)LVUtil_GetLParam(poad->hwndList, iItemFocus);
lstrcpyn(poad->poainfo->szApp, pai->szApp, sizeof(poad->poainfo->szApp));
PathUnquoteSpaces(poad->poainfo->szApp);
/* Did we register the association? */
poad->hr = IsDlgButtonChecked(poad->hDlg, IDD_MAKEASSOC) ? S_OK : S_FALSE;
/* Exec if requested. */
if (poad->poainfo->dwInFlags & OPENASINFO_FL_EXEC)
{
RunAs(poad);
SHAddToRecentDocs(RUNNING_NT ? SHARD_PATHA : SHARD_PATH,
poad->poainfo->pcszFile);
}
EndDialog(hDlg, TRUE);
break;
case IDCANCEL:
poad->hr = E_ABORT;
EndDialog(hDlg, FALSE);
break;
}
break;
default:
return FALSE;
}
return TRUE;
}
// external API version
HRESULT MyOpenAsDialog(HWND hwnd, POPENASINFO poainfo)
{
OPENAS_DATA oad;
int idDlg;
oad.hwnd = hwnd;
oad.poainfo = poainfo;
oad.szDescription[0] = 0;
oad.szTypeName[0] = 0;
TRACE_OUT(("Enter OpenAs for %s", oad.poainfo->pcszFile));
oad.lpszExt = PathFindExtension(oad.poainfo->pcszFile);
oad.lpcszClass = poainfo->pcszClass ? poainfo->pcszClass : oad.lpszExt;
if (*oad.lpszExt) {
LONG lTmp = sizeof(oad.szTypeName);
if ((RegQueryValue(HKEY_CLASSES_ROOT, oad.lpszExt, oad.szTypeName, &lTmp) == ERROR_SUCCESS)
&& (lTmp != 0) && (*oad.szTypeName)) {
idDlg = DLG_OPENAS;
} else
idDlg = DLG_OPENAS_NOTYPE;
} else {
idDlg = DLG_OPENAS;
}
oad.idDlg = idDlg;
return((DialogBoxParam(MLGetHinst(), MAKEINTRESOURCE(idDlg), hwnd,
OpenAsDlgProc, (LPARAM)(POPENAS_DATA)&oad) != -1)
? oad.hr : E_OUTOFMEMORY);
}
#if 0
/* BUILDBUILD: Not used in url.dll. Restore if added to shell32.dll. */
void WINAPI OpenAs_RunDLL(HWND hwnd, HINSTANCE hAppInstance, LPSTR lpszCmdLine, int nCmdShow)
{
OPENASINFO oainfo;
TRACE_OUT(("OpenAs_RunDLL is called with (%s)", lpszCmdLine));
oainfo.pcszFile = lpszCmdLine;
oainfo.pcszClass = NULL;
oainfo.dwInFlags = (OPENASINFO_FL_ALLOW_REGISTRATION |
OPENASINFO_FL_REGISTER_EXT |
OPENASINFO_FL_EXEC);
MyOpenAsDialog(hwnd, &oainfo);
}
#ifdef DEBUG
//
// Type checking
//
static RUNDLLPROC lpfnRunDLL = OpenAs_RunDLL;
#endif
#endif
Reference in a new issue Copy permalink