shellord.c File Reference

#include <wine/config.h>
#include <windef.h>
#include <winbase.h>
#include <wine/winternl.h>
#include <shlobj.h>
#include <undocshell.h>
#include <shlwapi.h>
#include <commdlg.h>
#include <commoncontrols.h>
#include "../shellrecyclebin/recyclebin.h"
#include <wine/debug.h>
#include <wine/unicode.h>
#include "pidl.h"
#include "shell32_main.h"

Include dependency graph for shellord.c:

Go to the source code of this file.

Classes
struct	tagCREATEMRULIST
struct	_PSXA
struct	_PSXA_CALL
struct	UxSubclassInfo

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COBJMACROS
#define	MRUF_STRING_LIST   0 /* list will contain strings */
#define	MRUF_BINARY_LIST   1 /* list will contain binary data */
#define	MRUF_DELAYED_SAVE   2 /* only save list order to reg. is FreeMRUList */

Typedefs
typedef struct tagCREATEMRULIST	CREATEMRULISTA
typedef struct tagCREATEMRULIST *	LPCREATEMRULISTA
typedef struct _PSXA	PSXA
typedef struct _PSXA *	PPSXA
typedef struct _PSXA_CALL	PSXA_CALL
typedef struct _PSXA_CALL *	PPSXA_CALL
typedef struct UxSubclassInfo	UxSubclassInfo

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
	WINE_DECLARE_DEBUG_CHANNEL (pidl)
HANDLE WINAPI	CreateMRUListA (LPCREATEMRULISTA lpcml)
VOID WINAPI	FreeMRUList (HANDLE hMRUList)
INT WINAPI	AddMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData)
INT WINAPI	FindMRUData (HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum)
INT WINAPI	EnumMRUListA (HANDLE hList, INT nItemPos, LPVOID lpBuffer, DWORD nBufferSize)
DWORD WINAPI	ParseFieldA (LPCSTR src, DWORD nField, LPSTR dst, DWORD len)
DWORD WINAPI	ParseFieldW (LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len)
DWORD WINAPI	ParseFieldAW (LPCVOID src, DWORD nField, LPVOID dst, DWORD len)
BOOL WINAPI	GetFileNameFromBrowse (HWND hwndOwner, LPWSTR lpstrFile, UINT nMaxFile, LPCWSTR lpstrInitialDir, LPCWSTR lpstrDefExt, LPCWSTR lpstrFilter, LPCWSTR lpstrTitle)
VOID WINAPI	SHGetSetSettings (LPSHELLSTATE lpss, DWORD dwMask, BOOL bSet)
VOID WINAPI	SHGetSettings (LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
LRESULT WINAPI	SHShellFolderView_Message (HWND hwndCabinet, UINT uMessage, LPARAM lParam)
BOOL WINAPI	RegisterShellHook (HWND hWnd, DWORD dwType)
int	ShellMessageBoxW (HINSTANCE hInstance, HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,...)
int	ShellMessageBoxA (HINSTANCE hInstance, HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,...)
HRESULT WINAPI	SHRegisterDragDrop (HWND hWnd, LPDROPTARGET pDropTarget)
HRESULT WINAPI	SHRevokeDragDrop (HWND hWnd)
HRESULT WINAPI	SHDoDragDrop (HWND hWnd, LPDATAOBJECT lpDataObject, LPDROPSOURCE lpDropSource, DWORD dwOKEffect, LPDWORD pdwEffect)
WORD WINAPI	ArrangeWindows (HWND hwndParent, DWORD dwReserved, const RECT *lpRect, WORD cKids, const HWND *lpKids)
BOOL WINAPI	SignalFileOpen (PCIDLIST_ABSOLUTE pidl)
static INT	SHADD_get_policy (LPCSTR policy, LPDWORD type, LPVOID buffer, LPDWORD len)
static INT CALLBACK	SHADD_compare_mru (LPCVOID data1, LPCVOID data2, DWORD cbData)
static INT	SHADD_create_add_mru_data (HANDLE mruhandle, LPCSTR doc_name, LPCSTR new_lnk_name, LPSTR buffer, INT *len)
void WINAPI	SHAddToRecentDocs (UINT uFlags, LPCVOID pv)
HRESULT WINAPI	SHCreateShellFolderViewEx (LPCSFV psvcbi, IShellView **ppv)
HRESULT WINAPI	SHWinHelp (HWND hwnd, LPCWSTR pszHelp, UINT uCommand, ULONG_PTR dwData)
BOOL WINAPI	SHRunControlPanel (_In_ LPCWSTR commandLine, _In_opt_ HWND parent)
VOID WINAPI	SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
HRESULT WINAPI	SHGetInstanceExplorer (IUnknown **lpUnknown)
void WINAPI	SHFreeUnusedLibraries (void)
BOOL WINAPI	DAD_AutoScroll (HWND hwnd, AUTO_SCROLL_DATA *samples, const POINT *pt)
BOOL WINAPI	DAD_DragEnter (_In_ HWND hwnd)
BOOL WINAPI	DAD_DragEnterEx (_In_ HWND hwnd, _In_ POINT p)
BOOL WINAPI	DAD_DragMove (_In_ POINT p)
BOOL WINAPI	DAD_DragLeave (VOID)
BOOL WINAPI	DAD_SetDragImage (_In_ HIMAGELIST himlTrack, _In_opt_ LPPOINT lppt)
BOOL WINAPI	DAD_ShowDragImage (_In_ BOOL bShow)
BOOL WINAPI	ReadCabinetState (CABINETSTATE *cs, int length)
BOOL WINAPI	WriteCabinetState (CABINETSTATE *cs)
BOOL WINAPI	FileIconInit (BOOL bFullInit)
HRESULT WINAPI	SetAppStartingCursor (HWND u, DWORD v)
HRESULT WINAPI	SHLoadOLE (LPARAM lParam)
int WINAPI	DriveType (int DriveType)
int WINAPI	InvalidateDriveType (int u)
HRESULT WINAPI	SHAbortInvokeCommand (void)
int WINAPI	SHOutOfMemoryMessageBox (HWND hwndOwner, LPCSTR lpCaption, UINT uType)
HRESULT WINAPI	SHFlushClipboard (void)
BOOL WINAPI	SHWaitForFileToOpen (LPCITEMIDLIST pidl, DWORD dwFlags, DWORD dwTimeout)
DWORD WINAPI	RLBuildListOfPaths (void)
BOOL WINAPI	SHValidateUNC (HWND hwndOwner, PWSTR pszFile, UINT fConnect)
DWORD WINAPI	DoEnvironmentSubstA (LPSTR pszString, UINT cchString)
DWORD WINAPI	DoEnvironmentSubstW (LPWSTR pszString, UINT cchString)
DWORD WINAPI	DoEnvironmentSubstAW (LPVOID x, UINT y)
BOOL WINAPI	GUIDFromStringA (LPCSTR str, LPGUID guid)
BOOL WINAPI	GUIDFromStringW (LPCWSTR str, LPGUID guid)
BOOL WINAPI	PathIsTemporaryA (LPSTR Str)
BOOL WINAPI	PathIsTemporaryW (LPWSTR Str)
static BOOL CALLBACK	PsxaCall (HPROPSHEETPAGE hpage, LPARAM lParam)
UINT WINAPI	SHAddFromPropSheetExtArray (HPSXA hpsxa, LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam)
HPSXA WINAPI	SHCreatePropSheetExtArray (HKEY hKey, LPCWSTR pszSubKey, UINT max_iface)
HPSXA WINAPI	SHCreatePropSheetExtArrayEx (HKEY hKey, LPCWSTR pszSubKey, UINT max_iface, LPDATAOBJECT pDataObj)
UINT WINAPI	SHReplaceFromPropSheetExtArray (HPSXA hpsxa, UINT uPageID, LPFNADDPROPSHEETPAGE lpfnReplaceWith, LPARAM lParam)
void WINAPI	SHDestroyPropSheetExtArray (HPSXA hpsxa)
HRESULT WINAPI	CIDLData_CreateFromIDArray (PCIDLIST_ABSOLUTE pidlFolder, UINT cpidlFiles, PCUIDLIST_RELATIVE_ARRAY lppidlFiles, LPDATAOBJECT *ppdataObject)
HRESULT WINAPI	SHCreateStdEnumFmtEtc (UINT cFormats, const FORMATETC *lpFormats, LPENUMFORMATETC *ppenumFormatetc)
BOOL WINAPI	SHFindFiles (PCIDLIST_ABSOLUTE pidlFolder, PCIDLIST_ABSOLUTE pidlSaveFile)
void WINAPI	SHUpdateImageW (LPCWSTR pszHashItem, int iIndex, UINT uFlags, int iImageIndex)
VOID WINAPI	SHUpdateImageA (LPCSTR pszHashItem, INT iIndex, UINT uFlags, INT iImageIndex)
INT WINAPI	SHHandleUpdateImage (PCIDLIST_ABSOLUTE pidlExtra)
BOOL WINAPI	SHObjectProperties (HWND hwnd, DWORD dwType, LPCWSTR szObject, LPCWSTR szPage)
BOOL WINAPI	SHGetNewLinkInfoA (LPCSTR pszLinkTo, LPCSTR pszDir, LPSTR pszName, BOOL *pfMustCopy, UINT uFlags)
BOOL WINAPI	SHGetNewLinkInfoW (LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName, BOOL *pfMustCopy, UINT uFlags)
HRESULT WINAPI	SHStartNetConnectionDialog (HWND hwnd, LPCSTR pszRemoteName, DWORD dwType)
HRESULT WINAPI	SHSetLocalizedName (LPCWSTR pszPath, LPCWSTR pszResModule, int idsRes)
BOOL WINAPI	LinkWindow_RegisterClass (void)
BOOL WINAPI	LinkWindow_UnregisterClass (DWORD dwUnused)
void WINAPI	SHFlushSFCache (void)
HRESULT WINAPI	SHGetImageList (int iImageList, REFIID riid, void **ppv)
HRESULT WINAPI	SHCreateShellFolderView (const SFV_CREATE *pcsfv, IShellView **ppsv)
EXTERN_C BOOL WINAPI	SHTestTokenMembership (HANDLE TokenHandle, ULONG ulRID)
BOOL WINAPI	IsUserAnAdmin (VOID)
static void	UxSubclassInfo_Destroy (UxSubclassInfo *pInfo)
static BOOL	DoSanitizeText (LPWSTR pszSanitized, LPCWSTR pszInvalidChars, LPCWSTR pszValidChars)
static void	DoSanitizeClipboard (HWND hwnd, UxSubclassInfo *pInfo)
static LRESULT CALLBACK	LimitEditWindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static UxSubclassInfo *	UxSubclassInfo_Create (HWND hwnd, LPWSTR valid, LPWSTR invalid)
HRESULT WINAPI	SHLimitInputEdit (HWND hWnd, IShellFolder *psf)

Variables
static HIMAGELIST	DAD_himlTrack = NULL
static POINT	DAD_ptHotspot
static BOOL	DAD_bDragging = FALSE
static LPUNKNOWN	SHELL32_IExplorerInterface =0

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 26 of file shellord.c.

COBJMACROS

#define COBJMACROS

Definition at line 27 of file shellord.c.

MRUF_BINARY_LIST

#define MRUF_BINARY_LIST   1 /* list will contain binary data */

Definition at line 66 of file shellord.c.

MRUF_DELAYED_SAVE

#define MRUF_DELAYED_SAVE   2 /* only save list order to reg. is FreeMRUList */

Definition at line 67 of file shellord.c.

MRUF_STRING_LIST

#define MRUF_STRING_LIST   0 /* list will contain strings */

Definition at line 65 of file shellord.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 25 of file shellord.c.

Typedef Documentation

CREATEMRULISTA

typedef struct tagCREATEMRULIST CREATEMRULISTA

LPCREATEMRULISTA

typedef struct tagCREATEMRULIST * LPCREATEMRULISTA

PPSXA

typedef struct _PSXA * PPSXA

PPSXA_CALL

typedef struct _PSXA_CALL * PPSXA_CALL

PSXA

typedef struct _PSXA PSXA

PSXA_CALL

typedef struct _PSXA_CALL PSXA_CALL

UxSubclassInfo

typedef struct UxSubclassInfo UxSubclassInfo

Function Documentation

AddMRUData()

INT WINAPI AddMRUData	(	HANDLE	hList,
		LPCVOID	lpData,
		DWORD	cbData
	)

Definition at line 462 of file comctl32undoc.c.

{
    LPWINEMRULIST mp = hList;
    LPWINEMRUITEM witem;
    INT i, replace;
 
    if ((replace = FindMRUData (hList, lpData, cbData, NULL)) >= 0) {
        /* Item exists, just move it to the front */
        LPWSTR pos = wcschr(mp->realMRU, replace + 'a');
        while (pos > mp->realMRU)
        {
            pos[0] = pos[-1];
            pos--;
        }
    }
    else {
    /* either add a new entry or replace oldest */
    if (mp->cursize < mp->extview.uMax) {
        /* Add in a new item */
        replace = mp->cursize;
        mp->cursize++;
    }
    else {
        /* get the oldest entry and replace data */
        replace = mp->realMRU[mp->cursize - 1] - 'a';
        Free(mp->array[replace]);
    }
 
        /* Allocate space for new item and move in the data */
        mp->array[replace] = witem = Alloc(cbData + sizeof(WINEMRUITEM));
        witem->itemFlag |= WMRUIF_CHANGED;
        witem->size = cbData;
        memcpy( &witem->datastart, lpData, cbData);
 
        /* now rotate MRU list */
        for(i=mp->cursize-1; i>=1; i--)
            mp->realMRU[i] = mp->realMRU[i-1];
    }
 
    /* The new item gets the front spot */
    mp->wineFlags |= WMRUF_CHANGED;
    mp->realMRU[0] = replace + 'a';
 
    TRACE("(%p, %p, %d) adding data, /%c/ now most current\n",
          hList, lpData, cbData, replace+'a');
 
    if (!(mp->extview.fFlags & MRU_CACHEWRITE)) {
    /* save changed stuff right now */
    MRU_SaveChanged( mp );
    }
 
    return replace;
}

Referenced by SHADD_create_add_mru_data(), and SHAddToRecentDocs().

ArrangeWindows()

WORD WINAPI ArrangeWindows	(	HWND	hwndParent,
		DWORD	dwReserved,
		const RECT *	lpRect,
		WORD	cKids,
		const HWND *	lpKids
	)

Definition at line 820 of file shellord.c.

{
    /* Unimplemented in WinXP SP3 */
    TRACE("(%p 0x%08x %p 0x%04x %p):stub.\n",
       hwndParent, dwReserved, lpRect, cKids, lpKids);
    return 0;
}

CIDLData_CreateFromIDArray()

HRESULT WINAPI CIDLData_CreateFromIDArray	(	PCIDLIST_ABSOLUTE	pidlFolder,
		UINT	cpidlFiles,
		PCUIDLIST_RELATIVE_ARRAY	lppidlFiles,
		LPDATAOBJECT *	ppdataObject
	)

Definition at line 2527 of file shellord.c.

{
    UINT i;
    HWND hwnd = 0;   /*FIXME: who should be hwnd of owner? set to desktop */
    HRESULT hResult;
 
    TRACE("(%p, %d, %p, %p)\n", pidlFolder, cpidlFiles, lppidlFiles, ppdataObject);
    if (TRACE_ON(pidl))
    {
    pdump (pidlFolder);
    for (i=0; i<cpidlFiles; i++) pdump (lppidlFiles[i]);
    }
    hResult = IDataObject_Constructor(hwnd, pidlFolder, lppidlFiles, cpidlFiles, FALSE, ppdataObject);
    return hResult;
}

Referenced by _CDataObject_CreateInstance(), CCabFolder::GetUIObjectOf(), CZipFolder::GetUIObjectOf(), CCommonFolder< TSelf, TItemId, TExtractIcon >::GetUIObjectOf(), test_AttributesRegistration(), test_MultipleFiles(), TestAdviseAndCanonical(), TestDefaultFormat(), and TestSetAndGetExtraFormat().

CreateMRUListA()

HANDLE WINAPI CreateMRUListA

(

LPCREATEMRULISTA

lpcml

)

Referenced by SHAddToRecentDocs().

DAD_AutoScroll()

BOOL WINAPI DAD_AutoScroll	(	HWND	hwnd,
		AUTO_SCROLL_DATA *	samples,
		const POINT *	pt
	)

Definition at line 1761 of file shellord.c.

{
    FIXME("hwnd = %p %p %p\n",hwnd,samples,pt);
    return FALSE;
}

DAD_DragEnter()

BOOL WINAPI DAD_DragEnter

(

_In_ HWND

hwnd

)

Definition at line 1776 of file shellord.c.

{
    POINT p;
 
    GetCursorPos(&p);
    return DAD_DragEnterEx(hwnd, p);
}

DAD_DragEnterEx()

BOOL WINAPI DAD_DragEnterEx	(	_In_ HWND	hwnd,
		_In_ POINT	p
	)

Definition at line 1796 of file shellord.c.

{
    if (!DAD_himlTrack)
        return FALSE;
 
    if (!ImageList_BeginDrag(DAD_himlTrack, 0, DAD_ptHotspot.x, DAD_ptHotspot.y))
        return FALSE;
 
    if (!ImageList_DragEnter(hwnd, p.x, p.y))
    {
        ImageList_EndDrag();
        return FALSE;
    }
 
    DAD_bDragging = TRUE;
    return TRUE;
}

Referenced by DAD_DragEnter().

DAD_DragLeave()

BOOL WINAPI DAD_DragLeave

(

VOID

)

Definition at line 1839 of file shellord.c.

{
    if (!DAD_bDragging)
        return FALSE;
 
    ImageList_DragLeave(NULL);
    ImageList_EndDrag();
    DAD_bDragging = FALSE;
    return TRUE;
}

Referenced by DAD_SetDragImage().

DAD_DragMove()

BOOL WINAPI DAD_DragMove

(

_In_ POINT

p

)

Definition at line 1824 of file shellord.c.

{
    if (!DAD_bDragging)
        return FALSE;
 
    return ImageList_DragMove(p.x, p.y);
}

DAD_SetDragImage()

BOOL WINAPI DAD_SetDragImage	(	_In_ HIMAGELIST	himlTrack,
		_In_opt_ LPPOINT	lppt
	)

Definition at line 1866 of file shellord.c.

{
    if (himlTrack == (HIMAGELIST)(ULONG_PTR)-1)
    {
        if (DAD_bDragging)
            DAD_DragLeave();
        DAD_himlTrack = NULL;
        return TRUE;
    }
 
    if (!himlTrack)
        return FALSE;
 
    DAD_himlTrack = himlTrack;
    if (lppt)
        DAD_ptHotspot = *lppt;
    else
        DAD_ptHotspot.x = DAD_ptHotspot.y = 0;
 
    return TRUE;
}

DAD_ShowDragImage()

BOOL WINAPI DAD_ShowDragImage

(

_In_ BOOL

bShow

)

Definition at line 1903 of file shellord.c.

{
    if (!DAD_bDragging)
        return FALSE;
 
    return ImageList_DragShowNolock(bShow);
} 

DoEnvironmentSubstA()

DWORD WINAPI DoEnvironmentSubstA	(	LPSTR	pszString,
		UINT	cchString
	)

Definition at line 2119 of file shellord.c.

{
    LPSTR dst;
    BOOL res = FALSE;
    DWORD len = cchString;
 
    TRACE("(%s, %d)\n", debugstr_a(pszString), cchString);
    if (pszString == NULL) /* Really return 0? */
        return 0;
    if ((dst = (LPSTR)HeapAlloc(GetProcessHeap(), 0, cchString * sizeof(CHAR))))
    {
        len = ExpandEnvironmentStringsA(pszString, dst, cchString);
        /* len includes the terminating 0 */
        if (len && len < cchString)
        {
            res = TRUE;
            memcpy(pszString, dst, len);
        }
        else
            len = cchString;
 
        HeapFree(GetProcessHeap(), 0, dst);
    }
    return MAKELONG(len, res);
}

Referenced by DoEnvironmentSubstAW(), and test_DoEnvironmentSubst().

DoEnvironmentSubstAW()

DWORD WINAPI DoEnvironmentSubstAW	(	LPVOID	x,
		UINT	y
	)

Definition at line 2194 of file shellord.c.

{
    if (SHELL_OsIsUnicode())
        return DoEnvironmentSubstW(x, y);
    return DoEnvironmentSubstA(x, y);
}

DoEnvironmentSubstW()

DWORD WINAPI DoEnvironmentSubstW	(	LPWSTR	pszString,
		UINT	cchString
	)

Definition at line 2164 of file shellord.c.

{
    LPWSTR dst;
    BOOL res = FALSE;
    DWORD len = cchString;
 
    TRACE("(%s, %d)\n", debugstr_w(pszString), cchString);
 
    if ((cchString < MAXLONG) && (dst = HeapAlloc(GetProcessHeap(), 0, cchString * sizeof(WCHAR))))
    {
        len = ExpandEnvironmentStringsW(pszString, dst, cchString);
        /* len includes the terminating 0 */
        if (len && len <= cchString)
        {
            res = TRUE;
            memcpy(pszString, dst, len * sizeof(WCHAR));
        }
        else
            len = cchString;
 
        HeapFree(GetProcessHeap(), 0, dst);
    }
    return MAKELONG(len, res);
}

Referenced by DoEnvironmentSubstAW(), and test_DoEnvironmentSubst().

DoSanitizeClipboard()

static void DoSanitizeClipboard ( HWND  hwnd, UxSubclassInfo *  pInfo  )

static

Definition at line 3051 of file shellord.c.

{
    HGLOBAL hData;
    LPWSTR pszText, pszSanitized;
    DWORD cbData;
 
    if (GetWindowLongPtrW(hwnd, GWL_STYLE) & ES_READONLY)
        return;
    if (!OpenClipboard(hwnd))
        return;
 
    hData = GetClipboardData(CF_UNICODETEXT);
    pszText = GlobalLock(hData);
    if (!pszText)
    {
        CloseClipboard();
        return;
    }
    SHStrDupW(pszText, &pszSanitized);
    GlobalUnlock(hData);
 
    if (pszSanitized &&
        DoSanitizeText(pszSanitized, pInfo->pwszInvalidChars, pInfo->pwszValidChars))
    {
        MessageBeep(0xFFFFFFFF);
 
        /* Update clipboard text */
        cbData = (lstrlenW(pszSanitized) + 1) * sizeof(WCHAR);
        hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, cbData);
        pszText = GlobalLock(hData);
        if (pszText)
        {
            CopyMemory(pszText, pszSanitized, cbData);
            GlobalUnlock(hData);
 
            SetClipboardData(CF_UNICODETEXT, hData);
        }
    }
 
    CoTaskMemFree(pszSanitized);
    CloseClipboard();
}

Referenced by LimitEditWindowProc().

DoSanitizeText()

static BOOL DoSanitizeText ( LPWSTR  pszSanitized, LPCWSTR  pszInvalidChars, LPCWSTR  pszValidChars  )

static

Definition at line 3018 of file shellord.c.

{
    LPWSTR pch1, pch2;
    BOOL bFound = FALSE;
 
    for (pch1 = pch2 = pszSanitized; *pch1; ++pch1)
    {
        if (pszInvalidChars)
        {
            if (wcschr(pszInvalidChars, *pch1) != NULL)
            {
                bFound = TRUE;
                continue;
            }
        }
        else if (pszValidChars)
        {
            if (wcschr(pszValidChars, *pch1) == NULL)
            {
                bFound = TRUE;
                continue;
            }
        }
 
        *pch2 = *pch1;
        ++pch2;
    }
    *pch2 = 0;
 
    return bFound;
}

Referenced by DoSanitizeClipboard().

DriveType()

int WINAPI DriveType

(

int

DriveType

)

Definition at line 2037 of file shellord.c.

{
    WCHAR root[] = L"A:\\";
    root[0] = L'A' + DriveType;
    return GetDriveTypeW(root);
}

EnumMRUListA()

INT WINAPI EnumMRUListA	(	HANDLE	hList,
		INT	nItemPos,
		LPVOID	lpBuffer,
		DWORD	nBufferSize
	)

Definition at line 860 of file comctl32undoc.c.

{
    const WINEMRULIST *mp = hList;
    LPWINEMRUITEM witem;
    INT desired, datasize;
    DWORD lenA;
 
    if (!mp) return -1;
    if ((nItemPos < 0) || !lpBuffer) return mp->cursize;
    if (nItemPos >= mp->cursize) return -1;
    desired = mp->realMRU[nItemPos];
    desired -= 'a';
    TRACE("nItemPos=%d, desired=%d\n", nItemPos, desired);
    witem = mp->array[desired];
    if(mp->extview.fFlags & MRU_BINARY) {
        datasize = min( witem->size, nBufferSize );
    memcpy( lpBuffer, &witem->datastart, datasize);
    } else {
        lenA = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
                   NULL, 0, NULL, NULL);
    datasize = min( lenA, nBufferSize );
    WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&witem->datastart, -1,
                lpBuffer, datasize, NULL, NULL);
        ((char *)lpBuffer)[ datasize - 1 ] = '\0';
        datasize = lenA - 1;
    }
    TRACE("(%p, %d, %p, %d): returning len=%d\n",
      hList, nItemPos, lpBuffer, nBufferSize, datasize);
    return datasize;
}

Referenced by SHAddToRecentDocs().

FileIconInit()

BOOL WINAPI FileIconInit

(

BOOL

bFullInit

)

Definition at line 1997 of file shellord.c.

{
    return SIC_Initialize();
}

Referenced by DisplayImageList(), and StartWithDesktop().

FindMRUData()

INT WINAPI FindMRUData	(	HANDLE	hList,
		LPCVOID	lpData,
		DWORD	cbData,
		LPINT	lpRegNum
	)

Definition at line 388 of file comctl32undoc.c.

{
    const WINEMRULIST *mp = hList;
    INT ret;
    UINT i;
    LPSTR dataA = NULL;
 
    if (!mp || !mp->extview.u.string_cmpfn)
    return -1;
 
    if(!(mp->extview.fFlags & MRU_BINARY) && !mp->isUnicode) {
        DWORD len = WideCharToMultiByte(CP_ACP, 0, lpData, -1,
                    NULL, 0, NULL, NULL);
    dataA = Alloc(len);
    WideCharToMultiByte(CP_ACP, 0, lpData, -1, dataA, len, NULL, NULL);
    }
 
    for(i=0; i<mp->cursize; i++) {
    if (mp->extview.fFlags & MRU_BINARY) {
        if (!mp->extview.u.binary_cmpfn(lpData, &mp->array[i]->datastart, cbData))
        break;
    }
    else {
        if(mp->isUnicode) {
            if (!mp->extview.u.string_cmpfn(lpData, (LPWSTR)&mp->array[i]->datastart))
            break;
        } else {
            DWORD len = WideCharToMultiByte(CP_ACP, 0,
                        (LPWSTR)&mp->array[i]->datastart, -1,
                        NULL, 0, NULL, NULL);
        LPSTR itemA = Alloc(len);
        INT cmp;
        WideCharToMultiByte(CP_ACP, 0, (LPWSTR)&mp->array[i]->datastart, -1,
                    itemA, len, NULL, NULL);
 
            cmp = mp->extview.u.string_cmpfn((LPWSTR)dataA, (LPWSTR)itemA);
        Free(itemA);
        if(!cmp)
            break;
        }
    }
    }
    Free(dataA);
    if (i < mp->cursize)
    ret = i;
    else
    ret = -1;
    if (lpRegNum && (ret != -1))
    *lpRegNum = 'a' + i;
 
    TRACE("(%p, %p, %d, %p) returning %d\n",
       hList, lpData, cbData, lpRegNum, ret);
 
    return ret;
}

Referenced by SHAddToRecentDocs().

FreeMRUList()

VOID WINAPI FreeMRUList

(

HANDLE

hMRUList

)

Definition at line 348 of file comctl32undoc.c.

{
    LPWINEMRULIST mp = hMRUList;
    UINT i;
 
    TRACE("(%p)\n", hMRUList);
    if (!hMRUList)
        return;
 
    if (mp->wineFlags & WMRUF_CHANGED) {
    /* need to open key and then save the info */
    MRU_SaveChanged( mp );
    }
 
    for(i=0; i<mp->extview.uMax; i++)
        Free(mp->array[i]);
 
    Free(mp->realMRU);
    Free(mp->array);
    Free(mp->extview.lpszSubKey);
    Free(mp);
}

Referenced by SHAddToRecentDocs().

GetFileNameFromBrowse()

BOOL WINAPI GetFileNameFromBrowse	(	HWND	hwndOwner,
		LPWSTR	lpstrFile,
		UINT	nMaxFile,
		LPCWSTR	lpstrInitialDir,
		LPCWSTR	lpstrDefExt,
		LPCWSTR	lpstrFilter,
		LPCWSTR	lpstrTitle
	)

Definition at line 158 of file shellord.c.

{
typedef BOOL (WINAPI *GetOpenFileNameProc)(OPENFILENAMEW *ofn);
    HMODULE hmodule;
    GetOpenFileNameProc pGetOpenFileNameW;
    OPENFILENAMEW ofn;
    BOOL ret;
 
    TRACE("%p, %s, %d, %s, %s, %s, %s)\n",
      hwndOwner, debugstr_w(lpstrFile), nMaxFile, lpstrInitialDir, lpstrDefExt,
      lpstrFilter, lpstrTitle);
 
    hmodule = LoadLibraryW(L"comdlg32.dll");
    if(!hmodule) return FALSE;
    pGetOpenFileNameW = (GetOpenFileNameProc)GetProcAddress(hmodule, "GetOpenFileNameW");
    if(!pGetOpenFileNameW)
    {
    FreeLibrary(hmodule);
    return FALSE;
    }
 
    memset(&ofn, 0, sizeof(ofn));
 
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hwndOwner;
    ofn.lpstrFilter = lpstrFilter;
    ofn.lpstrFile = lpstrFile;
    ofn.nMaxFile = nMaxFile;
    ofn.lpstrInitialDir = lpstrInitialDir;
    ofn.lpstrTitle = lpstrTitle;
    ofn.lpstrDefExt = lpstrDefExt;
    ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_FILEMUSTEXIST;
    ret = pGetOpenFileNameW(&ofn);
 
    FreeLibrary(hmodule);
    return ret;
}

GUIDFromStringA()

BOOL WINAPI GUIDFromStringA	(	LPCSTR	str,
		LPGUID	guid
	)

Definition at line 2204 of file shellord.c.

{
    ANSI_STRING ansi_str;
    WCHAR szWide[40];
    UNICODE_STRING guid_str = { 0, sizeof(szWide), szWide };
    if (*str != '{')
        return FALSE;
    RtlInitAnsiString(&ansi_str, str);
    return !RtlAnsiStringToUnicodeString(&guid_str, &ansi_str, FALSE) &&
           !RtlGUIDFromString(&guid_str, guid);
}

Referenced by TEST_GUIDFromStringA().

GUIDFromStringW()

BOOL WINAPI GUIDFromStringW	(	LPCWSTR	str,
		LPGUID	guid
	)

Definition at line 2219 of file shellord.c.

{
    UNICODE_STRING guid_str;
    if (!str || *str != L'{')
        return FALSE;
    RtlInitUnicodeString(&guid_str, str);
    return !RtlGUIDFromString(&guid_str, guid);
}

InvalidateDriveType()

int WINAPI InvalidateDriveType

(

int

u

)

Definition at line 2047 of file shellord.c.

{
    TRACE("0x%08x stub\n",u);
    return 0;
}

IsUserAnAdmin()

BOOL WINAPI IsUserAnAdmin

(

VOID

)

Definition at line 2982 of file shellord.c.

{
    return SHTestTokenMembership(NULL, DOMAIN_ALIAS_RID_ADMINS);
}

Referenced by CStartMenuBtnCtxMenu::AddStartContextMenuItems(), InitializeServerAdminUI(), prepare_and_run_test(), ProcessRunOnceItems(), and run_registry_test().

LimitEditWindowProc()

static LRESULT CALLBACK LimitEditWindowProc ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 3095 of file shellord.c.

{
    WNDPROC fnWndProc;
    WCHAR wch;
    UxSubclassInfo *pInfo = GetPropW(hwnd, L"UxSubclassInfo");
    if (!pInfo)
        return DefWindowProcW(hwnd, uMsg, wParam, lParam);
 
    fnWndProc = pInfo->fnWndProc;
 
    switch (uMsg)
    {
        case WM_KEYDOWN:
            if (GetKeyState(VK_SHIFT) < 0 && wParam == VK_INSERT)
                DoSanitizeClipboard(hwnd, pInfo);
            else if (GetKeyState(VK_CONTROL) < 0 && wParam == L'V')
                DoSanitizeClipboard(hwnd, pInfo);
 
            return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
 
        case WM_PASTE:
            DoSanitizeClipboard(hwnd, pInfo);
            return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
 
        case WM_CHAR:
            if (GetKeyState(VK_CONTROL) < 0 && wParam == L'V')
                break;
 
            if (pInfo->pwszInvalidChars)
            {
                if (wcschr(pInfo->pwszInvalidChars, (WCHAR)wParam) != NULL)
                {
                    MessageBeep(0xFFFFFFFF);
                    break;
                }
            }
            else if (pInfo->pwszValidChars)
            {
                if (wcschr(pInfo->pwszValidChars, (WCHAR)wParam) == NULL)
                {
                    MessageBeep(0xFFFFFFFF);
                    break;
                }
            }
            return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
 
        case WM_UNICHAR:
            if (wParam == UNICODE_NOCHAR)
                return TRUE;
 
            /* FALL THROUGH */
 
        case WM_IME_CHAR:
            wch = (WCHAR)wParam;
            if (GetKeyState(VK_CONTROL) < 0 && wch == L'V')
                break;
 
            if (!IsWindowUnicode(hwnd) && HIBYTE(wch) != 0)
            {
                CHAR data[] = {HIBYTE(wch), LOBYTE(wch)};
                MultiByteToWideChar(CP_ACP, 0, data, 2, &wch, 1);
            }
 
            if (pInfo->pwszInvalidChars)
            {
                if (wcschr(pInfo->pwszInvalidChars, wch) != NULL)
                {
                    MessageBeep(0xFFFFFFFF);
                    break;
                }
            }
            else if (pInfo->pwszValidChars)
            {
                if (wcschr(pInfo->pwszValidChars, wch) == NULL)
                {
                    MessageBeep(0xFFFFFFFF);
                    break;
                }
            }
            return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
 
        case WM_NCDESTROY:
            UxSubclassInfo_Destroy(pInfo);
            return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
 
        default:
            return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
    }
 
    return 0;
}

Referenced by UxSubclassInfo_Create().

LinkWindow_RegisterClass()

BOOL WINAPI LinkWindow_RegisterClass

(

void

)

Definition at line 2809 of file shellord.c.

{
    FIXME("()\n");
    return TRUE;
}

LinkWindow_UnregisterClass()

BOOL WINAPI LinkWindow_UnregisterClass

(

DWORD

dwUnused

)

Definition at line 2818 of file shellord.c.

{
    FIXME("()\n");
    return TRUE;
}

ParseFieldA()

DWORD WINAPI ParseFieldA	(	LPCSTR	src,
		DWORD	nField,
		LPSTR	dst,
		DWORD	len
	)

Definition at line 87 of file shellord.c.

{
    WARN("(%s,0x%08x,%p,%d) semi-stub.\n",debugstr_a(src),nField,dst,len);
 
    if (!src || !src[0] || !dst || !len)
      return 0;
 
    /* skip n fields delimited by ',' */
    while (nField > 1)
    {
      if (*src=='\0') return FALSE;
      if (*(src++)==',') nField--;
    }
 
    /* copy part till the next ',' to dst */
    while ( *src!='\0' && *src!=',' && (len--)>0 ) *(dst++)=*(src++);
 
    /* finalize the string */
    *dst=0x0;
 
    return TRUE;
}

Referenced by HCR_RegGetIconA(), and ParseFieldAW().

ParseFieldAW()

DWORD WINAPI ParseFieldAW	(	LPCVOID	src,
		DWORD	nField,
		LPVOID	dst,
		DWORD	len
	)

Definition at line 147 of file shellord.c.

{
    if (SHELL_OsIsUnicode())
      return ParseFieldW(src, nField, dst, len);
    return ParseFieldA(src, nField, dst, len);
}

ParseFieldW()

DWORD WINAPI ParseFieldW	(	LPCWSTR	src,
		DWORD	nField,
		LPWSTR	dst,
		DWORD	len
	)

Definition at line 121 of file shellord.c.

{
    WARN("(%s,0x%08x,%p,%d) semi-stub.\n", debugstr_w(src), nField, dst, len);
 
    if (!src || !src[0] || !dst || !len)
      return 0;
 
    /* skip n fields delimited by ',' */
    while (nField > 1)
    {
      if (*src == 0x0) return FALSE;
      if (*src++ == ',') nField--;
    }
 
    /* copy part till the next ',' to dst */
    while ( *src != 0x0 && *src != ',' && (len--)>0 ) *(dst++) = *(src++);
 
    /* finalize the string */
    *dst = 0x0;
 
    return TRUE;
}

Referenced by CFSExtractIcon_CreateInstance(), HCR_RegGetIconW(), and ParseFieldAW().

PathIsTemporaryA()

BOOL WINAPI PathIsTemporaryA

(

LPSTR

Str

)

Definition at line 2235 of file shellord.c.

{
#ifdef __REACTOS__
    WCHAR szWide[MAX_PATH];
 
    TRACE("(%s)\n", debugstr_a(Str));
 
    SHAnsiToUnicode(Str, szWide, _countof(szWide));
    return PathIsTemporaryW(szWide);
#else
    FIXME("(%s)stub\n", debugstr_a(Str));
    return FALSE;
#endif
}

Referenced by Test_PathIsTemporaryA().

PathIsTemporaryW()

BOOL WINAPI PathIsTemporaryW

(

LPWSTR

Str

)

Definition at line 2258 of file shellord.c.

{
#ifdef __REACTOS__
    WCHAR szLongPath[MAX_PATH], szTempPath[MAX_PATH];
    DWORD attrs;
    LPCWSTR pszTarget = Str;
 
    TRACE("(%s)\n", debugstr_w(Str));
 
    attrs = GetFileAttributesW(Str);
    if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_TEMPORARY))
        return TRUE;
 
    if (!GetTempPathW(_countof(szTempPath), szTempPath) ||
        !GetLongPathNameW(szTempPath, szTempPath, _countof(szTempPath)))
    {
        return FALSE;
    }
 
    if (GetLongPathNameW(Str, szLongPath, _countof(szLongPath)))
        pszTarget = szLongPath;
 
    return (PathIsEqualOrSubFolder(szTempPath, pszTarget) ||
            PathIsEqualOrSubFolder(UlongToPtr(CSIDL_INTERNET_CACHE), pszTarget) ||
            PathIsEqualOrSubFolder(UlongToPtr(CSIDL_CDBURN_AREA), pszTarget));
#else
    FIXME("(%s)stub\n", debugstr_w(Str));
    return FALSE;
#endif
}

Referenced by PathIsTemporaryA(), and Test_PathIsTemporaryW().

PsxaCall()

static BOOL CALLBACK PsxaCall ( HPROPSHEETPAGE  hpage, LPARAM  lParam  )

static

Definition at line 2306 of file shellord.c.

{
    PPSXA_CALL Call = (PPSXA_CALL)lParam;
 
    if (Call != NULL)
    {
        if ((Call->bMultiple || !Call->bCalled) &&
            Call->lpfnAddReplaceWith(hpage, Call->lParam))
        {
            Call->bCalled = TRUE;
            Call->uiCount++;
            return TRUE;
        }
    }
 
    return FALSE;
}

Referenced by SHAddFromPropSheetExtArray(), and SHReplaceFromPropSheetExtArray().

ReadCabinetState()

BOOL WINAPI ReadCabinetState	(	CABINETSTATE *	cs,
		int	length
	)

Definition at line 1915 of file shellord.c.

{
    HKEY hkey = 0;
    DWORD type, r;
    C_ASSERT(sizeof(*cs) == FIELD_OFFSET(CABINETSTATE, fMenuEnumFilter) + sizeof(UINT));
 
    TRACE("%p %d\n", cs, length);
 
    if( (cs == NULL) || (length < (int)sizeof(*cs))  )
        return FALSE;
 
    r = RegOpenKeyW( HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CabinetState", &hkey );
    if( r == ERROR_SUCCESS )
    {
        type = REG_BINARY;
        r = RegQueryValueExW( hkey, L"Settings",
            NULL, &type, (LPBYTE)cs, (LPDWORD)&length );
        RegCloseKey( hkey );
 
    }
 
    /* if we can't read from the registry, create default values */
    if ( (r != ERROR_SUCCESS) || (cs->cLength < sizeof(*cs)) ||
        (cs->cLength != length) )
    {
        SHELLSTATE shellstate;
        shellstate.fWin95Classic = FALSE;
        SHGetSetSettings(&shellstate, SSF_WIN95CLASSIC, FALSE);
 
        TRACE("Initializing shell cabinet settings\n");
        memset(cs, 0, sizeof(*cs));
        cs->cLength          = sizeof(*cs);
        cs->nVersion         = 2;
        cs->fFullPathTitle   = FALSE;
        cs->fSaveLocalView   = TRUE;
        cs->fNotShell        = FALSE;
        cs->fSimpleDefault   = TRUE;
        cs->fDontShowDescBar = FALSE;
        cs->fNewWindowMode   = shellstate.fWin95Classic;
        cs->fShowCompColor   = FALSE;
        cs->fDontPrettyNames = FALSE;
        cs->fAdminsCreateCommonGroups = TRUE;
        cs->fMenuEnumFilter  = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
    }
 
    return TRUE;
}

Referenced by full_title(), IntGetNewWindowMode(), IntSetNewWindowMode(), CabinetStateSettings::Load(), and ViewDlg_Apply().

RegisterShellHook()

BOOL WINAPI RegisterShellHook	(	HWND	hWnd,
		DWORD	dwType
	)

Definition at line 521 of file shellord.c.

{
    if (dwType == 3)
    {
        SetTaskmanWindow(hWnd);
        return RegisterShellHookWindow(hWnd);
    }
    else if (dwType == 0)
    {
        return DeregisterShellHookWindow(hWnd);
    }
 
    ERR("Unsupported argument");
    return FALSE;
}

Referenced by CTaskSwitchWnd::OnCreate(), and CTaskSwitchWnd::OnDestroy().

RLBuildListOfPaths()

DWORD WINAPI RLBuildListOfPaths

(

void

)

Definition at line 2100 of file shellord.c.

{   FIXME("stub\n");
    return 0;
}

SetAppStartingCursor()

HRESULT WINAPI SetAppStartingCursor	(	HWND	u,
		DWORD	v
	)

Definition at line 2005 of file shellord.c.

{   FIXME("hwnd=%p 0x%04x stub\n",u,v );
    return 0;
}

SHAbortInvokeCommand()

HRESULT WINAPI SHAbortInvokeCommand

(

void

)

Definition at line 2056 of file shellord.c.

{   FIXME("stub\n");
    return 1;
}

SHADD_compare_mru()

static INT CALLBACK SHADD_compare_mru ( LPCVOID  data1, LPCVOID  data2, DWORD  cbData  )

static

Definition at line 899 of file shellord.c.

{
#ifdef __REACTOS__
    LPCWSTR psz1, psz2;
    INT iCmp = lstrcmpiW(data1, data2);
    if (iCmp != 0)
        return iCmp;
    psz1 = data1;
    psz2 = data2;
    psz1 += lstrlenW(psz1) + 1;
    psz2 += lstrlenW(psz2) + 1;
    return lstrcmpiW(psz1, psz2);
#else
    return lstrcmpiA(data1, data2);
#endif
}

Referenced by SHAddToRecentDocs().

SHADD_create_add_mru_data()

static INT SHADD_create_add_mru_data ( HANDLE  mruhandle, LPCSTR  doc_name, LPCSTR  new_lnk_name, LPSTR  buffer, INT *  len  )

static

Definition at line 967 of file shellord.c.

{
    LPSTR ptr;
    INT wlen;
 
    /*FIXME: Document:
     *  RecentDocs MRU data structure seems to be:
     *    +0h   document file name w/ terminating 0h
     *    +nh   short int w/ size of remaining
     *    +n+2h 02h 30h, or 01h 30h, or 00h 30h  -  unknown
     *    +n+4h 10 bytes zeros  -   unknown
     *    +n+eh shortcut file name w/ terminating 0h
     *    +n+e+nh 3 zero bytes  -  unknown
     */
 
    /* Create the MRU data structure for "RecentDocs"
     */
    ptr = buffer;
    lstrcpyA(ptr, doc_name);
    ptr += (lstrlenA(buffer) + 1);
    wlen= lstrlenA(new_lnk_name) + 1 + 12;
    *((short int*)ptr) = wlen;
    ptr += 2;   /* step past the length */
    *(ptr++) = 0x30;  /* unknown reason */
    *(ptr++) = 0;     /* unknown, but can be 0x00, 0x01, 0x02 */
    memset(ptr, 0, 10);
    ptr += 10;
    lstrcpyA(ptr, new_lnk_name);
    ptr += (lstrlenA(new_lnk_name) + 1);
    memset(ptr, 0, 3);
    ptr += 3;
    *len = ptr - buffer;
 
    /* Add the new entry into the MRU list
     */
    return AddMRUData(mruhandle, buffer, *len);
}

Referenced by SHAddToRecentDocs().

SHADD_get_policy()

static INT SHADD_get_policy ( LPCSTR  policy, LPDWORD  type, LPVOID  buffer, LPDWORD  len  )

static

Definition at line 858 of file shellord.c.

{
    HKEY Policy_basekey;
    INT ret;
 
    /* Get the key for the policies location in the registry
     */
    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
              "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
              0, KEY_READ, &Policy_basekey)) {
 
    if (RegOpenKeyExA(HKEY_CURRENT_USER,
              "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
              0, KEY_READ, &Policy_basekey)) {
        TRACE("No Explorer Policies location exists. Policy wanted=%s\n",
          policy);
        *len = 0;
        return ERROR_FILE_NOT_FOUND;
    }
    }
 
    /* Retrieve the data if it exists
     */
    ret = SHQueryValueExA(Policy_basekey, policy, 0, type, buffer, len);
    RegCloseKey(Policy_basekey);
    return ret;
}

Referenced by SHAddToRecentDocs().

SHAddFromPropSheetExtArray()

UINT WINAPI SHAddFromPropSheetExtArray	(	HPSXA	hpsxa,
		LPFNADDPROPSHEETPAGE	lpfnAddPage,
		LPARAM	lParam
	)

Definition at line 2327 of file shellord.c.

{
    PSXA_CALL Call;
    UINT i;
    PPSXA psxa = (PPSXA)hpsxa;
 
    TRACE("(%p,%p,%08lx)\n", hpsxa, lpfnAddPage, lParam);
 
    if (psxa)
    {
        ZeroMemory(&Call, sizeof(Call));
        Call.lpfnAddReplaceWith = lpfnAddPage;
        Call.lParam = lParam;
        Call.bMultiple = TRUE;
 
        /* Call the AddPage method of all registered IShellPropSheetExt interfaces */
        for (i = 0; i != psxa->uiCount; i++)
        {
            psxa->pspsx[i]->lpVtbl->AddPages(psxa->pspsx[i], PsxaCall, (LPARAM)&Call);
        }
 
        return Call.uiCount;
    }
 
    return 0;
}

Referenced by Applet(), DisplayAdvancedSettings(), KeyboardApplet(), MouseApplet(), and SystemApplet().

SHAddToRecentDocs()

void WINAPI SHAddToRecentDocs	(	UINT	uFlags,
		LPCVOID	pv
	)

Definition at line 1022 of file shellord.c.

{
#ifdef __REACTOS__
    INT ret;
    WCHAR szTargetPath[MAX_PATH], szLinkDir[MAX_PATH], szLinkFile[MAX_PATH], szDescription[80];
    WCHAR szPath[MAX_PATH];
    DWORD cbBuffer;
    HANDLE hFind;
    WIN32_FIND_DATAW find;
    HKEY hExplorerKey;
    LONG error;
    LPWSTR pchDotExt, pchTargetTitle, pchLinkTitle;
    MRUINFOW mru;
    HANDLE hMRUList = NULL;
    IShellLinkW *psl = NULL;
    IPersistFile *pPf = NULL;
    HRESULT hr;
    BYTE Buffer[(MAX_PATH + 64) * sizeof(WCHAR)];
 
    TRACE("%04x %p\n", uFlags, pv);
 
    /* check policy */
    ret = SHRestricted(REST_NORECENTDOCSHISTORY);
    TRACE("policy value for NoRecentDocsHistory = %08x\n", ret);
    if (ret != 0)
        return;
 
    /* store to szTargetPath */
    szTargetPath[0] = 0;
    if (pv)
    {
        switch (uFlags)
        {
            case SHARD_PATHA:
                MultiByteToWideChar(CP_ACP, 0, pv, -1, szLinkDir, ARRAYSIZE(szLinkDir));
                GetFullPathNameW(szLinkDir, ARRAYSIZE(szTargetPath), szTargetPath, NULL);
                break;
 
            case SHARD_PATHW:
                GetFullPathNameW(pv, ARRAYSIZE(szTargetPath), szTargetPath, NULL);
                break;
 
            case SHARD_PIDL:
                SHGetPathFromIDListW(pv, szLinkDir);
                GetFullPathNameW(szLinkDir, ARRAYSIZE(szTargetPath), szTargetPath, NULL);
                break;
 
            default:
                FIXME("Unsupported flags: %u\n", uFlags);
                return;
        }
    }
 
    /* get recent folder */
    if (!SHGetSpecialFolderPathW(NULL, szLinkDir, CSIDL_RECENT, FALSE))
    {
        ERR("serious issues 1\n");
        return;
    }
    TRACE("Users Recent dir %S\n", szLinkDir);
 
    /* open Explorer key */
    error = RegCreateKeyExW(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer",
                            0, NULL, 0,
                            KEY_READ | KEY_WRITE, NULL, &hExplorerKey, NULL);
    if (error)
    {
        ERR("Failed to RegCreateKeyExW: 0x%08X\n", error);
        return;
    }
 
    if (!pv)
    {
        TRACE("pv is NULL, so delete all shortcut files in %S\n", szLinkDir);
 
        lstrcpynW(szLinkFile, szLinkDir, ARRAYSIZE(szLinkFile));
        PathAppendW(szLinkFile, L"*.lnk");
 
        hFind = FindFirstFileW(szLinkFile, &find);
        if (hFind != INVALID_HANDLE_VALUE)
        {
            do
            {
                lstrcpynW(szLinkFile, szLinkDir, ARRAYSIZE(szLinkFile));
                PathAppendW(szLinkFile, find.cFileName);
                DeleteFileW(szLinkFile);
            } while (FindNextFile(hFind, &find));
            FindClose(hFind);
        }
 
        SHDeleteKeyW(hExplorerKey, L"RecentDocs");
        RegCloseKey(hExplorerKey);
        return;
    }
 
    if (szTargetPath[0] == 0 || !PathFileExistsW(szTargetPath) ||
        PathIsDirectoryW(szTargetPath))
    {
        /* path is not normal file */
        RegCloseKey(hExplorerKey);
        return;
    }
 
    hr = CoInitialize(NULL);
    if (FAILED(hr))
    {
        ERR("CoInitialize: %08X\n", hr);
        RegCloseKey(hExplorerKey);
        return;
    }
 
    /* check if file is a shortcut */
    ret = 0;
    pchDotExt = PathFindExtensionW(szTargetPath);
    while (lstrcmpiW(pchDotExt, L".lnk") == 0)
    {
        hr = IShellLink_ConstructFromPath(szTargetPath, &IID_IShellLinkW, (LPVOID*)&psl);
        if (FAILED(hr))
        {
            ERR("IShellLink_ConstructFromPath: 0x%08X\n", hr);
            goto Quit;
        }
 
        IShellLinkW_GetPath(psl, szPath, ARRAYSIZE(szPath), NULL, 0);
        IShellLinkW_Release(psl);
        psl = NULL;
 
        lstrcpynW(szTargetPath, szPath, ARRAYSIZE(szTargetPath));
        pchDotExt = PathFindExtensionW(szTargetPath);
 
        if (++ret >= 8)
        {
            ERR("Link loop?\n");
            goto Quit;
        }
    }
    if (!lstrcmpiW(pchDotExt, L".exe"))
    {
        /* executables are not added */
        goto Quit;
    }
 
    /* ***  JOB 0: Build strings *** */
 
    pchTargetTitle = PathFindFileNameW(szTargetPath);
 
    lstrcpyW(szDescription, L"Shortcut to ");
    StrCatBuffW(szDescription, pchTargetTitle, ARRAYSIZE(szDescription));
 
    lstrcpynW(szLinkFile, szLinkDir, ARRAYSIZE(szLinkFile));
    PathAppendW(szLinkFile, pchTargetTitle);
    StrCatBuffW(szLinkFile, L".lnk", ARRAYSIZE(szLinkFile));
    pchLinkTitle = PathFindFileNameW(szLinkFile);
 
    /* ***  JOB 1: Update registry for ...\Explorer\RecentDocs list  *** */
 
    /* store MRU data */
    cbBuffer = sizeof(Buffer);
    ret = DoStoreMRUData(Buffer, &cbBuffer, pchTargetTitle, szTargetPath, pchLinkTitle);
    if (!ret)
    {
        ERR("DoStoreMRUData failed: %d\n", ret);
        goto Quit;
    }
 
    /* create MRU list */
    mru.cbSize = sizeof(mru);
    mru.uMax = 16;
    mru.fFlags = MRU_BINARY | MRU_CACHEWRITE;
    mru.hKey = hExplorerKey;
    mru.lpszSubKey = L"RecentDocs";
    mru.lpfnCompare = (MRUCMPPROCW)SHADD_compare_mru;
    hMRUList = CreateMRUListW(&mru);
    if (!hMRUList)
    {
        ERR("CreateMRUListW failed\n");
        goto Quit;
    }
 
    /* already exists? */
    ret = FindMRUData(hMRUList, Buffer, cbBuffer, NULL);
    if (ret >= 0)
    {
        /* Just touch for speed */
        HANDLE hFile;
        hFile = CreateFileW(szLinkFile, GENERIC_READ | GENERIC_WRITE,
                            FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
        if (hFile != INVALID_HANDLE_VALUE)
        {
            TRACE("Just touch file '%S'.\n", szLinkFile);
            CloseHandle(hFile);
            goto Quit;
        }
    }
 
    /* add MRU data */
    ret = AddMRUData(hMRUList, Buffer, cbBuffer);
    if (ret < 0)
    {
        ERR("AddMRUData failed: %d\n", ret);
        goto Quit;
    }
 
    /* ***  JOB 2: Create shortcut in user's "Recent" directory  *** */
 
    hr = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
                          &IID_IShellLinkW, (LPVOID *)&psl);
    if (FAILED(hr))
    {
        ERR("CoInitialize for IID_IShellLinkW: %08X\n", hr);
        goto Quit;
    }
 
    hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID *)&pPf);
    if (FAILED(hr))
    {
        ERR("IShellLinkW_QueryInterface: %08X\n", hr);
        goto Quit;
    }
 
    if (uFlags == SHARD_PIDL)
        hr = IShellLinkW_SetIDList(psl, pv);
    else
        hr = IShellLinkW_SetPath(psl, pv);
 
    IShellLinkW_SetDescription(psl, szDescription);
 
    hr = IPersistFile_Save(pPf, szLinkFile, TRUE);
    if (FAILED(hr))
    {
        ERR("IPersistFile_Save: 0x%08X\n", hr);
    }
 
    hr = IPersistFile_SaveCompleted(pPf, szLinkFile);
    if (FAILED(hr))
    {
        ERR("IPersistFile_SaveCompleted: 0x%08X\n", hr);
    }
 
Quit:
    if (hMRUList)
        FreeMRUList(hMRUList);
    if (pPf)
        IPersistFile_Release(pPf);
    if (psl)
        IShellLinkW_Release(psl);
    CoUninitialize();
    RegCloseKey(hExplorerKey);
#else
/* If list is a string list lpfnCompare has the following prototype
 * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
 * for binary lists the prototype is
 * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
 * where cbData is the no. of bytes to compare.
 * Need to check what return value means identical - 0?
 */
 
 
    UINT olderrormode;
    HKEY HCUbasekey;
    CHAR doc_name[MAX_PATH];
    CHAR link_dir[MAX_PATH];
    CHAR new_lnk_filepath[MAX_PATH];
    CHAR new_lnk_name[MAX_PATH];
    CHAR * ext;
    IMalloc *ppM;
    LPITEMIDLIST pidl;
    HWND hwnd = 0;       /* FIXME:  get real window handle */
    INT ret;
    DWORD data[64], datalen, type;
 
    TRACE("%04x %p\n", uFlags, pv);
 
    /*FIXME: Document:
     *  RecentDocs MRU data structure seems to be:
     *    +0h   document file name w/ terminating 0h
     *    +nh   short int w/ size of remaining
     *    +n+2h 02h 30h, or 01h 30h, or 00h 30h  -  unknown
     *    +n+4h 10 bytes zeros  -   unknown
     *    +n+eh shortcut file name w/ terminating 0h
     *    +n+e+nh 3 zero bytes  -  unknown
     */
 
    /* See if we need to do anything.
     */
    datalen = 64;
    ret=SHADD_get_policy( "NoRecentDocsHistory", &type, data, &datalen);
    if ((ret > 0) && (ret != ERROR_FILE_NOT_FOUND)) {
    ERR("Error %d getting policy \"NoRecentDocsHistory\"\n", ret);
    return;
    }
    if (ret == ERROR_SUCCESS) {
    if (!( (type == REG_DWORD) ||
           ((type == REG_BINARY) && (datalen == 4)) )) {
        ERR("Error policy data for \"NoRecentDocsHistory\" not formatted correctly, type=%d, len=%d\n",
        type, datalen);
        return;
    }
 
    TRACE("policy value for NoRecentDocsHistory = %08x\n", data[0]);
    /* now test the actual policy value */
    if ( data[0] != 0)
        return;
    }
 
    /* Open key to where the necessary info is
     */
    /* FIXME: This should be done during DLL PROCESS_ATTACH (or THREAD_ATTACH)
     *        and the close should be done during the _DETACH. The resulting
     *        key is stored in the DLL global data.
     */
    if (RegCreateKeyExA(HKEY_CURRENT_USER,
            "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
            0, 0, 0, KEY_READ, 0, &HCUbasekey, 0)) {
    ERR("Failed to create 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer'\n");
    return;
    }
 
    /* Get path to user's "Recent" directory
     */
    if(SUCCEEDED(SHGetMalloc(&ppM))) {
    if (SUCCEEDED(SHGetSpecialFolderLocation(hwnd, CSIDL_RECENT,
                         &pidl))) {
        SHGetPathFromIDListA(pidl, link_dir);
        IMalloc_Free(ppM, pidl);
    }
    else {
        /* serious issues */
        link_dir[0] = 0;
        ERR("serious issues 1\n");
    }
    IMalloc_Release(ppM);
    }
    else {
    /* serious issues */
    link_dir[0] = 0;
    ERR("serious issues 2\n");
    }
    TRACE("Users Recent dir %s\n", link_dir);
 
    /* If no input, then go clear the lists */
    if (!pv) {
    /* clear user's Recent dir
     */
 
    /* FIXME: delete all files in "link_dir"
     *
     * while( more files ) {
     *    lstrcpyA(old_lnk_name, link_dir);
     *    PathAppendA(old_lnk_name, filenam);
     *    DeleteFileA(old_lnk_name);
     * }
     */
    FIXME("should delete all files in %s\\\n", link_dir);
 
    /* clear MRU list
     */
    /* MS Bug ?? v4.72.3612.1700 of shell32 does the delete against
     *  HKEY_LOCAL_MACHINE version of ...CurrentVersion\Explorer
     *  and naturally it fails w/ rc=2. It should do it against
     *  HKEY_CURRENT_USER which is where it is stored, and where
     *  the MRU routines expect it!!!!
     */
    RegDeleteKeyA(HCUbasekey, "RecentDocs");
    RegCloseKey(HCUbasekey);
    return;
    }
 
    /* Have data to add, the jobs to be done:
     *   1. Add document to MRU list in registry "HKCU\Software\
     *      Microsoft\Windows\CurrentVersion\Explorer\RecentDocs".
     *   2. Add shortcut to document in the user's Recent directory
     *      (CSIDL_RECENT).
     *   3. Add shortcut to Start menu's Documents submenu.
     */
 
    /* Get the pure document name from the input
     */
    switch (uFlags)
    {
    case SHARD_PIDL:
        if (!SHGetPathFromIDListA(pv, doc_name))
        {
            WARN("can't get path from PIDL\n");
            return;
        }
        break;
 
    case SHARD_PATHA:
        lstrcpynA(doc_name, pv, MAX_PATH);
        break;
 
    case SHARD_PATHW:
        WideCharToMultiByte(CP_ACP, 0, pv, -1, doc_name, MAX_PATH, NULL, NULL);
        break;
 
    default:
        FIXME("Unsupported flags: %u\n", uFlags);
        return;
    }
 
    TRACE("full document name %s\n", debugstr_a(doc_name));
 
    PathStripPathA(doc_name);
    TRACE("stripped document name %s\n", debugstr_a(doc_name));
 
 
    /* ***  JOB 1: Update registry for ...\Explorer\RecentDocs list  *** */
 
    {  /* on input needs:
    *      doc_name    -  pure file-spec, no path
    *      link_dir    -  path to the user's Recent directory
    *      HCUbasekey  -  key of ...Windows\CurrentVersion\Explorer" node
    * creates:
    *      new_lnk_name-  pure file-spec, no path for new .lnk file
    *      new_lnk_filepath
    *                  -  path and file name of new .lnk file
    */
    CREATEMRULISTA mymru;
    HANDLE mruhandle;
    INT len, pos, bufused, err;
    INT i;
    DWORD attr;
    CHAR buffer[2048];
    CHAR *ptr;
    CHAR old_lnk_name[MAX_PATH];
    short int slen;
 
    mymru.cbSize = sizeof(CREATEMRULISTA);
    mymru.nMaxItems = 15;
    mymru.dwFlags = MRUF_BINARY_LIST | MRUF_DELAYED_SAVE;
    mymru.hKey = HCUbasekey;
    mymru.lpszSubKey = "RecentDocs";
        mymru.lpfnCompare = SHADD_compare_mru;
    mruhandle = CreateMRUListA(&mymru);
    if (!mruhandle) {
        /* MRU failed */
        ERR("MRU processing failed, handle zero\n");
        RegCloseKey(HCUbasekey);
        return;
    }
    len = lstrlenA(doc_name);
    pos = FindMRUData(mruhandle, doc_name, len, 0);
 
    /* Now get the MRU entry that will be replaced
     * and delete the .lnk file for it
     */
    if ((bufused = EnumMRUListA(mruhandle, (pos == -1) ? 14 : pos,
                                    buffer, 2048)) != -1) {
        ptr = buffer;
        ptr += (lstrlenA(buffer) + 1);
        slen = *((short int*)ptr);
        ptr += 2;  /* skip the length area */
        if (bufused >= slen + (ptr-buffer)) {
        /* buffer size looks good */
        ptr += 12; /* get to string */
        len = bufused - (ptr-buffer);  /* get length of buf remaining */
                if (ptr[0] && (lstrlenA(ptr) <= len-1)) {
            /* appears to be good string */
            lstrcpyA(old_lnk_name, link_dir);
            PathAppendA(old_lnk_name, ptr);
            if (!DeleteFileA(old_lnk_name)) {
            if ((attr = GetFileAttributesA(old_lnk_name)) == INVALID_FILE_ATTRIBUTES) {
                if ((err = GetLastError()) != ERROR_FILE_NOT_FOUND) {
                ERR("Delete for %s failed, err=%d, attr=%08x\n",
                    old_lnk_name, err, attr);
                }
                else {
                TRACE("old .lnk file %s did not exist\n",
                      old_lnk_name);
                }
            }
            else {
                ERR("Delete for %s failed, attr=%08x\n",
                old_lnk_name, attr);
            }
            }
            else {
            TRACE("deleted old .lnk file %s\n", old_lnk_name);
            }
        }
        }
    }
 
    /* Create usable .lnk file name for the "Recent" directory
     */
    wsprintfA(new_lnk_name, "%s.lnk", doc_name);
    lstrcpyA(new_lnk_filepath, link_dir);
    PathAppendA(new_lnk_filepath, new_lnk_name);
    i = 1;
    olderrormode = SetErrorMode(SEM_FAILCRITICALERRORS);
    while (GetFileAttributesA(new_lnk_filepath) != INVALID_FILE_ATTRIBUTES) {
        i++;
        wsprintfA(new_lnk_name, "%s (%u).lnk", doc_name, i);
        lstrcpyA(new_lnk_filepath, link_dir);
        PathAppendA(new_lnk_filepath, new_lnk_name);
    }
    SetErrorMode(olderrormode);
    TRACE("new shortcut will be %s\n", new_lnk_filepath);
 
    /* Now add the new MRU entry and data
     */
    pos = SHADD_create_add_mru_data(mruhandle, doc_name, new_lnk_name,
                    buffer, &len);
    FreeMRUList(mruhandle);
    TRACE("Updated MRU list, new doc is position %d\n", pos);
    }
 
    /* ***  JOB 2: Create shortcut in user's "Recent" directory  *** */
 
    {  /* on input needs:
    *      doc_name    -  pure file-spec, no path
    *      new_lnk_filepath
    *                  -  path and file name of new .lnk file
    *      uFlags[in]  -  flags on call to SHAddToRecentDocs
    *      pv[in]      -  document path/pidl on call to SHAddToRecentDocs
    */
    IShellLinkA *psl = NULL;
    IPersistFile *pPf = NULL;
    HRESULT hres;
    CHAR desc[MAX_PATH];
    WCHAR widelink[MAX_PATH];
 
    CoInitialize(0);
 
    hres = CoCreateInstance( &CLSID_ShellLink,
                 NULL,
                 CLSCTX_INPROC_SERVER,
                 &IID_IShellLinkA,
                 (LPVOID )&psl);
    if(SUCCEEDED(hres)) {
 
        hres = IShellLinkA_QueryInterface(psl, &IID_IPersistFile,
                         (LPVOID *)&pPf);
        if(FAILED(hres)) {
        /* bombed */
        ERR("failed QueryInterface for IPersistFile %08x\n", hres);
        goto fail;
        }
 
        /* Set the document path or pidl */
        if (uFlags == SHARD_PIDL) {
                hres = IShellLinkA_SetIDList(psl, pv);
        } else {
                hres = IShellLinkA_SetPath(psl, pv);
        }
        if(FAILED(hres)) {
        /* bombed */
        ERR("failed Set{IDList|Path} %08x\n", hres);
        goto fail;
        }
 
        lstrcpyA(desc, "Shortcut to ");
        lstrcatA(desc, doc_name);
        hres = IShellLinkA_SetDescription(psl, desc);
        if(FAILED(hres)) {
        /* bombed */
        ERR("failed SetDescription %08x\n", hres);
        goto fail;
        }
 
        MultiByteToWideChar(CP_ACP, 0, new_lnk_filepath, -1,
                widelink, MAX_PATH);
        /* create the short cut */
        hres = IPersistFile_Save(pPf, widelink, TRUE);
        if(FAILED(hres)) {
        /* bombed */
        ERR("failed IPersistFile::Save %08x\n", hres);
        IPersistFile_Release(pPf);
        IShellLinkA_Release(psl);
        goto fail;
        }
        hres = IPersistFile_SaveCompleted(pPf, widelink);
        IPersistFile_Release(pPf);
        IShellLinkA_Release(psl);
        TRACE("shortcut %s has been created, result=%08x\n",
          new_lnk_filepath, hres);
    }
    else {
        ERR("CoCreateInstance failed, hres=%08x\n", hres);
    }
    }
 
 fail:
    CoUninitialize();
 
    /* all done */
    RegCloseKey(HCUbasekey);
    return;
#endif
}

Referenced by CShellDispatch::AddToRecent(), ClearRecentAndMru(), DoOpenFile(), DoSaveFile(), Preview_pLoadImage(), SetFileName(), and RegistrySettings::SetMostRecentFile().

SHCreatePropSheetExtArray()

HPSXA WINAPI SHCreatePropSheetExtArray	(	HKEY	hKey,
		LPCWSTR	pszSubKey,
		UINT	max_iface
	)

Definition at line 2357 of file shellord.c.

{
    return SHCreatePropSheetExtArrayEx(hKey, pszSubKey, max_iface, NULL);
}

Referenced by Applet(), DisplayApplet(), KeyboardApplet(), MouseApplet(), and SystemApplet().

SHCreatePropSheetExtArrayEx()

HPSXA WINAPI SHCreatePropSheetExtArrayEx	(	HKEY	hKey,
		LPCWSTR	pszSubKey,
		UINT	max_iface,
		LPDATAOBJECT	pDataObj
	)

Definition at line 2365 of file shellord.c.

{
    WCHAR szHandler[64];
    DWORD dwHandlerLen;
    WCHAR szClsidHandler[39];
    DWORD dwClsidSize;
    CLSID clsid;
    LONG lRet;
    DWORD dwIndex;
    IShellExtInit *psxi;
    IShellPropSheetExt *pspsx;
    HKEY hkBase, hkPropSheetHandlers;
    PPSXA psxa = NULL;
 
    TRACE("(%p,%s,%u)\n", hKey, debugstr_w(pszSubKey), max_iface);
 
    if (max_iface == 0)
        return NULL;
 
    /* Open the registry key */
    lRet = RegOpenKeyW(hKey, pszSubKey, &hkBase);
    if (lRet != ERROR_SUCCESS)
        return NULL;
 
    lRet = RegOpenKeyExW(hkBase, L"shellex\\PropertySheetHandlers", 0, KEY_ENUMERATE_SUB_KEYS, &hkPropSheetHandlers);
    RegCloseKey(hkBase);
    if (lRet == ERROR_SUCCESS)
    {
        /* Create and initialize the Property Sheet Extensions Array */
        psxa = LocalAlloc(LMEM_FIXED, FIELD_OFFSET(PSXA, pspsx[max_iface]));
        if (psxa)
        {
            ZeroMemory(psxa, FIELD_OFFSET(PSXA, pspsx[max_iface]));
            psxa->uiAllocated = max_iface;
 
            /* Enumerate all subkeys and attempt to load the shell extensions */
            dwIndex = 0;
            do
            {
                dwHandlerLen = sizeof(szHandler) / sizeof(szHandler[0]);
                lRet = RegEnumKeyExW(hkPropSheetHandlers, dwIndex++, szHandler, &dwHandlerLen, NULL, NULL, NULL, NULL);
                if (lRet != ERROR_SUCCESS)
                {
                    if (lRet == ERROR_MORE_DATA)
                        continue;
 
                    if (lRet == ERROR_NO_MORE_ITEMS)
                        lRet = ERROR_SUCCESS;
                    break;
                }
 
                /* The CLSID is stored either in the key itself or in its default value. */
                if (FAILED(lRet = SHCLSIDFromStringW(szHandler, &clsid)))
                {
                    dwClsidSize = sizeof(szClsidHandler);
                    if (SHGetValueW(hkPropSheetHandlers, szHandler, NULL, NULL, szClsidHandler, &dwClsidSize) == ERROR_SUCCESS)
                    {
                        /* Force a NULL-termination and convert the string */
                        szClsidHandler[(sizeof(szClsidHandler) / sizeof(szClsidHandler[0])) - 1] = 0;
                        lRet = SHCLSIDFromStringW(szClsidHandler, &clsid);
                    }
                }
 
                if (SUCCEEDED(lRet))
                {
                    /* Attempt to get an IShellPropSheetExt and an IShellExtInit instance.
                       Only if both interfaces are supported it's a real shell extension.
                       Then call IShellExtInit's Initialize method. */
                    if (SUCCEEDED(CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER/* | CLSCTX_NO_CODE_DOWNLOAD */, &IID_IShellPropSheetExt, (LPVOID *)&pspsx)))
                    {
                        if (SUCCEEDED(pspsx->lpVtbl->QueryInterface(pspsx, &IID_IShellExtInit, (PVOID *)&psxi)))
                        {
                            if (SUCCEEDED(psxi->lpVtbl->Initialize(psxi, NULL, pDataObj, hKey)))
                            {
                                /* Add the IShellPropSheetExt instance to the array */
                                psxa->pspsx[psxa->uiCount++] = pspsx;
                            }
                            else
                            {
                                psxi->lpVtbl->Release(psxi);
                                pspsx->lpVtbl->Release(pspsx);
                            }
                        }
                        else
                            pspsx->lpVtbl->Release(pspsx);
                    }
                }
 
            } while (psxa->uiCount != psxa->uiAllocated);
        }
        else
            lRet = ERROR_NOT_ENOUGH_MEMORY;
 
        RegCloseKey(hkPropSheetHandlers);
    }
 
    if (lRet != ERROR_SUCCESS && psxa)
    {
        SHDestroyPropSheetExtArray((HPSXA)psxa);
        psxa = NULL;
    }
 
    return (HPSXA)psxa;
}

Referenced by SHCreatePropSheetExtArray().

SHCreateShellFolderView()

HRESULT WINAPI SHCreateShellFolderView	(	const SFV_CREATE *	pcsfv,
		IShellView **	ppsv
	)

Definition at line 2896 of file shellord.c.

{
    IShellView * psf;
    HRESULT hRes;
 
    *ppsv = NULL;
    if (!pcsfv || pcsfv->cbSize != sizeof(*pcsfv))
      return E_INVALIDARG;
 
    TRACE("sf=%p outer=%p callback=%p\n",
      pcsfv->pshf, pcsfv->psvOuter, pcsfv->psfvcb);
 
    hRes = IShellView_Constructor(pcsfv->pshf, &psf);
    if (FAILED(hRes))
        return hRes;
 
    hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppsv);
    IShellView_Release(psf);
 
    return hRes;
}

SHCreateShellFolderViewEx()

HRESULT WINAPI SHCreateShellFolderViewEx	(	LPCSFV	psvcbi,
		IShellView **	ppv
	)

Definition at line 1628 of file shellord.c.

{
    IShellView * psf;
    HRESULT hRes;
 
    TRACE("sf=%p pidl=%p cb=%p mode=0x%08x parm=%p\n",
      psvcbi->pshf, psvcbi->pidl, psvcbi->pfnCallback,
      psvcbi->fvm, psvcbi->psvOuter);
 
    *ppv = NULL;
    hRes = IShellView_Constructor(psvcbi->pshf, &psf);
 
    if (FAILED(hRes))
        return hRes;
 
    hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
    IShellView_Release(psf);
 
    return hRes;
}

SHCreateStdEnumFmtEtc()

HRESULT WINAPI SHCreateStdEnumFmtEtc	(	UINT	cFormats,
		const FORMATETC *	lpFormats,
		LPENUMFORMATETC *	ppenumFormatetc
	)

Definition at line 2553 of file shellord.c.

{
    IEnumFORMATETC *pef;
    HRESULT hRes;
    TRACE("cf=%d fe=%p pef=%p\n", cFormats, lpFormats, ppenumFormatetc);
 
    hRes = IEnumFORMATETC_Constructor(cFormats, lpFormats, &pef);
    if (FAILED(hRes))
        return hRes;
 
    IEnumFORMATETC_AddRef(pef);
    hRes = IEnumFORMATETC_QueryInterface(pef, &IID_IEnumFORMATETC, (LPVOID*)ppenumFormatetc);
    IEnumFORMATETC_Release(pef);
 
    return hRes;
}

Referenced by CDevSettings_EnumFormatEtc().

SHDestroyPropSheetExtArray()

void WINAPI SHDestroyPropSheetExtArray

(

HPSXA

hpsxa

)

Definition at line 2504 of file shellord.c.

{
    UINT i;
    PPSXA psxa = (PPSXA)hpsxa;
 
    TRACE("(%p)\n", hpsxa);
 
    if (psxa)
    {
        for (i = 0; i != psxa->uiCount; i++)
        {
            psxa->pspsx[i]->lpVtbl->Release(psxa->pspsx[i]);
        }
 
        LocalFree(psxa);
    }
}

Referenced by Applet(), DisplayAdvancedSettings(), DisplayApplet(), KeyboardApplet(), MouseApplet(), SHCreatePropSheetExtArrayEx(), and SystemApplet().

SHDoDragDrop()

HRESULT WINAPI SHDoDragDrop	(	HWND	hWnd,
		LPDATAOBJECT	lpDataObject,
		LPDROPSOURCE	lpDropSource,
		DWORD	dwOKEffect,
		LPDWORD	pdwEffect
	)

Definition at line 804 of file shellord.c.

{
    FIXME("(%p %p %p 0x%08x %p):stub.\n",
    hWnd, lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
    return DoDragDrop(lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
}

ShellMessageBoxA()

int ShellMessageBoxA	(	HINSTANCE	hInstance,
		HWND	hWnd,
		LPCSTR	lpText,
		LPCSTR	lpCaption,
		UINT	uType,
			...
	)

Definition at line 637 of file shellord.c.

{
#ifdef __REACTOS__
    CHAR *szText = NULL, szTitle[100];
    LPCSTR pszText, pszTitle = szTitle;
    LPSTR pszTemp;
    __ms_va_list args;
    int ret;
 
    __ms_va_start(args, uType);
 
    TRACE("(%p,%p,%p,%p,%08x)\n", hInstance, hWnd, lpText, lpCaption, uType);
 
    if (IS_INTRESOURCE(lpCaption))
        LoadStringA(hInstance, LOWORD(lpCaption), szTitle, ARRAY_SIZE(szTitle));
    else
        pszTitle = lpCaption;
 
    if (IS_INTRESOURCE(lpText))
    {
        /* Retrieve the length of the Unicode string and obtain the maximum
         * possible length for the corresponding ANSI string (not counting
         * any possible NULL-terminator). */
        const WCHAR *ptr;
        UINT len = LoadStringW(hInstance, LOWORD(lpText), (LPWSTR)&ptr, 0);
 
        len = WideCharToMultiByte(CP_ACP, 0, ptr, len,
                                  NULL, 0, NULL, NULL);
 
        if (len)
        {
            szText = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(CHAR));
            if (szText) LoadStringA(hInstance, LOWORD(lpText), szText, len + 1);
        }
        pszText = szText;
        if (!pszText) {
            WARN("Failed to load id %d\n", LOWORD(lpText));
            __ms_va_end(args);
            return 0;
        }
    }
    else
        pszText = lpText;
 
    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
                   pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
 
    __ms_va_end(args);
 
    ret = MessageBoxA(hWnd, pszTemp, pszTitle, uType | MB_SETFOREGROUND);
 
    HeapFree(GetProcessHeap(), 0, szText);
    LocalFree(pszTemp);
    return ret;
 
#else // __REACTOS__
 
// Wine version, broken.
    char    szText[100],szTitle[100];
    LPCSTR  pszText = szText, pszTitle = szTitle;
    LPSTR   pszTemp;
    __ms_va_list args;
    int ret;
 
    __ms_va_start(args, uType);
    /* wvsprintfA(buf,fmt, args); */
 
    TRACE("(%p,%p,%p,%p,%08x)\n",
        hInstance,hWnd,lpText,lpCaption,uType);
 
    if (IS_INTRESOURCE(lpCaption))
      LoadStringA(hInstance, LOWORD(lpCaption), szTitle, sizeof(szTitle));
    else
      pszTitle = lpCaption;
 
    if (IS_INTRESOURCE(lpText))
      LoadStringA(hInstance, LOWORD(lpText), szText, sizeof(szText));
    else
      pszText = lpText;
 
    FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
               pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
 
    __ms_va_end(args);
 
    ret = MessageBoxA(hWnd,pszTemp,pszTitle,uType);
        LocalFree(pszTemp);
    return ret;
#endif
}

ShellMessageBoxW()

int ShellMessageBoxW	(	HINSTANCE	hInstance,
		HWND	hWnd,
		LPCWSTR	lpText,
		LPCWSTR	lpCaption,
		UINT	uType,
			...
	)

Definition at line 566 of file shellord.c.

{
    WCHAR   szText[100],szTitle[100];
    LPCWSTR pszText = szText, pszTitle = szTitle;
    LPWSTR  pszTemp;
    __ms_va_list args;
    int ret;
 
    __ms_va_start(args, uType);
    /* wvsprintfA(buf,fmt, args); */
 
    TRACE("(%p,%p,%p,%p,%08x)\n",
        hInstance,hWnd,lpText,lpCaption,uType);
 
    if (IS_INTRESOURCE(lpCaption))
      LoadStringW(hInstance, LOWORD(lpCaption), szTitle, ARRAY_SIZE(szTitle));
    else
      pszTitle = lpCaption;
 
    if (IS_INTRESOURCE(lpText))
      LoadStringW(hInstance, LOWORD(lpText), szText, ARRAY_SIZE(szText));
    else
      pszText = lpText;
 
    FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
               pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
 
    __ms_va_end(args);
 
    ret = MessageBoxW(hWnd,pszTemp,pszTitle,uType);
        LocalFree(pszTemp);
    return ret;
}

SHFindFiles()

BOOL WINAPI SHFindFiles	(	PCIDLIST_ABSOLUTE	pidlFolder,
		PCIDLIST_ABSOLUTE	pidlSaveFile
	)

Definition at line 2576 of file shellord.c.

{
    FIXME("params ignored: %p %p\n", pidlFolder, pidlSaveFile);
    if (SHRestricted(REST_NOFIND))
    {
        return FALSE;
    }
    /* Open the search results folder */
    /* FIXME: CSearchBar should be opened as well */
    return ShellExecuteW(NULL, NULL, L"explorer.exe", L"::{E17D4FC0-5564-11D1-83F2-00A0C90DC849}", NULL, SW_SHOWNORMAL) > (HINSTANCE)32;
}

Referenced by CTaskSwitchWnd::HandleAppCommand(), CTrayWindow::HandleCommand(), CTrayWindow::HandleHotKey(), and CDesktopBrowser::OnCommand().

SHFlushClipboard()

HRESULT WINAPI SHFlushClipboard

(

void

)

Definition at line 2076 of file shellord.c.

{
    return OleFlushClipboard();
}

SHFlushSFCache()

void WINAPI SHFlushSFCache

(

void

)

Definition at line 2834 of file shellord.c.

{
}

SHFreeUnusedLibraries()

void WINAPI SHFreeUnusedLibraries

(

void

)

Definition at line 1752 of file shellord.c.

{
    FIXME("stub\n");
    CoFreeUnusedLibraries();
}

SHGetImageList()

HRESULT WINAPI SHGetImageList	(	int	iImageList,
		REFIID	riid,
		void **	ppv
	)

Definition at line 2848 of file shellord.c.

{
    HIMAGELIST hLarge, hSmall;
    HIMAGELIST hNew;
    HRESULT ret = E_FAIL;
 
    /* Wine currently only maintains large and small image lists */
    if ((iImageList != SHIL_LARGE) && (iImageList != SHIL_SMALL) && (iImageList != SHIL_SYSSMALL))
    {
        FIXME("Unsupported image list %i requested\n", iImageList);
        return E_FAIL;
    }
 
    Shell_GetImageLists(&hLarge, &hSmall);
#ifndef __REACTOS__
    hNew = ImageList_Duplicate(iImageList == SHIL_LARGE ? hLarge : hSmall);
 
    /* Get the interface for the new image list */
    if (hNew)
    {
        ret = HIMAGELIST_QueryInterface(hNew, riid, ppv);
        ImageList_Destroy(hNew);
    }
#else
    /* Duplicating the imagelist causes the start menu items not to draw on
     * the first show. Was the Duplicate necessary for some reason? I believe
     * Windows returns the raw pointer here. */
    hNew = (iImageList == SHIL_LARGE ? hLarge : hSmall);
    ret = IImageList2_QueryInterface((IImageList2 *) hNew, riid, ppv);
#endif
 
    return ret;
}

Referenced by check_icon_size(), CSearchBar::OnInitDialog(), CISFBand::SetImageListIconSize(), CAddressBand::SetSite(), test_get_file_info_iconlist(), test_SHGetImageList(), and CMenuToolbarBase::UpdateImageLists().

SHGetInstanceExplorer()

HRESULT WINAPI SHGetInstanceExplorer

(

IUnknown **

lpUnknown

)

Definition at line 1728 of file shellord.c.

{   TRACE("%p\n", lpUnknown);
 
    *lpUnknown = SHELL32_IExplorerInterface;
 
    if (!SHELL32_IExplorerInterface)
      return E_FAIL;
 
    IUnknown_AddRef(SHELL32_IExplorerInterface);
    return S_OK;
}

Referenced by _SHGetInstanceExplorer(), and SHOpenFolderWindow().

SHGetNewLinkInfoA()

BOOL WINAPI SHGetNewLinkInfoA	(	LPCSTR	pszLinkTo,
		LPCSTR	pszDir,
		LPSTR	pszName,
		BOOL *	pfMustCopy,
		UINT	uFlags
	)

Definition at line 2713 of file shellord.c.

{
    WCHAR wszLinkTo[MAX_PATH];
    WCHAR wszDir[MAX_PATH];
    WCHAR wszName[MAX_PATH];
    BOOL res;
 
    MultiByteToWideChar(CP_ACP, 0, pszLinkTo, -1, wszLinkTo, MAX_PATH);
    MultiByteToWideChar(CP_ACP, 0, pszDir, -1, wszDir, MAX_PATH);
 
    res = SHGetNewLinkInfoW(wszLinkTo, wszDir, wszName, pfMustCopy, uFlags);
 
    if (res)
        WideCharToMultiByte(CP_ACP, 0, wszName, -1, pszName, MAX_PATH, NULL, NULL);
 
    return res;
}

Referenced by test_sh_new_link_info().

SHGetNewLinkInfoW()

BOOL WINAPI SHGetNewLinkInfoW	(	LPCWSTR	pszLinkTo,
		LPCWSTR	pszDir,
		LPWSTR	pszName,
		BOOL *	pfMustCopy,
		UINT	uFlags
	)

Definition at line 2732 of file shellord.c.

{
    const WCHAR *basename;
    WCHAR *dst_basename;
    int i=2;
 
    TRACE("(%s, %s, %p, %p, 0x%08x)\n", debugstr_w(pszLinkTo), debugstr_w(pszDir),
          pszName, pfMustCopy, uFlags);
 
    *pfMustCopy = FALSE;
 
    if (uFlags & SHGNLI_PIDL)
    {
        FIXME("SHGNLI_PIDL flag unsupported\n");
        return FALSE;
    }
 
    if (uFlags)
        FIXME("ignoring flags: 0x%08x\n", uFlags);
 
    /* FIXME: should test if the file is a shortcut or DOS program */
    if (GetFileAttributesW(pszLinkTo) == INVALID_FILE_ATTRIBUTES)
        return FALSE;
 
    basename = strrchrW(pszLinkTo, '\\');
    if (basename)
        basename = basename+1;
    else
        basename = pszLinkTo;
 
    lstrcpynW(pszName, pszDir, MAX_PATH);
    if (!PathAddBackslashW(pszName))
        return FALSE;
 
    dst_basename = pszName + strlenW(pszName);
 
    snprintfW(dst_basename, pszName + MAX_PATH - dst_basename, L"%s.lnk", basename);
 
    while (GetFileAttributesW(pszName) != INVALID_FILE_ATTRIBUTES)
    {
        snprintfW(dst_basename, pszName + MAX_PATH - dst_basename, L"%s (%d).lnk", basename, i);
        i++;
    }
 
    return TRUE;
}

Referenced by SHGetNewLinkInfoA(), and SHGetNewLinkInfoWrapW().

SHGetSetSettings()

VOID WINAPI SHGetSetSettings	(	LPSHELLSTATE	lpss,
		DWORD	dwMask,
		BOOL	bSet
	)

Definition at line 229 of file shellord.c.

{
#ifdef __REACTOS__
    const DWORD inverted = SSF_SHOWEXTENSIONS;
    LPSHELLSTATE gpss = &g_ShellState.ss;
    HKEY hKeyAdv;
 
    if (!SHELL_GlobalCounterIsInitialized(g_hShellState))
    {
        SHELL_GlobalCounterCreate(&SHGCGUID_ShellState, g_hShellState);
    }
 
    if (!lpss)
    {
        SHELL_GlobalCounterIncrement(SHELL_GCOUNTER_SHELLSTATE);
        return;
    }
 
    hKeyAdv = SHGetShellKey(SHKEY_Root_HKCU | SHKEY_Key_Explorer, L"Advanced", bSet);
    if (!hKeyAdv && bSet)
        return;
 
#define SSF_STRUCTONLY (SSF_NOCONFIRMRECYCLE | SSF_DOUBLECLICKINWEBVIEW | SSF_DESKTOPHTML | \
                        SSF_WIN95CLASSIC | SSF_SORTCOLUMNS | SSF_STARTPANELON)
#define SSF_ALL (0x07FFFFFF & ~0x40)
#define SSF_IMPLEMENTED ((SSF_ALL) & ~(SSF_SERVERADMINUI)) // SERVERADMINUI is written by Explorer and read by IsOS()
#define SHGSS_GetSetStruct(getsetmacro) \
    do { \
        getsetmacro(fNoConfirmRecycle, SSF_NOCONFIRMRECYCLE); \
        getsetmacro(fDoubleClickInWebView, SSF_DOUBLECLICKINWEBVIEW); \
        getsetmacro(fDesktopHTML, SSF_DESKTOPHTML); \
        getsetmacro(fWin95Classic, SSF_WIN95CLASSIC); \
        getsetmacro(lParamSort, SSF_SORTCOLUMNS); \
        getsetmacro(iSortDirection, SSF_SORTCOLUMNS); \
        getsetmacro(fStartPanelOn, SSF_STARTPANELON); \
    } while (0)
#define SHGSS_GetSetAdv(getsetmacro) \
    do { \
        getsetmacro(L"HideFileExt", fShowExtensions, SSF_SHOWEXTENSIONS); \
        getsetmacro(L"ShowCompColor", fShowCompColor, SSF_SHOWCOMPCOLOR); \
        getsetmacro(L"DontPrettyPath", fDontPrettyPath, SSF_DONTPRETTYPATH); \
        getsetmacro(L"ShowAttribCol", fShowAttribCol, SSF_SHOWATTRIBCOL); \
        getsetmacro(L"MapNetDrvBtn", fMapNetDrvBtn, SSF_MAPNETDRVBUTTON); \
        getsetmacro(L"ShowInfoTip", fShowInfoTip, SSF_SHOWINFOTIP); \
        getsetmacro(L"HideIcons", fHideIcons, SSF_HIDEICONS); \
        getsetmacro(L"WebView", fWebView, SSF_WEBVIEW); \
        getsetmacro(L"Filter", fFilter, SSF_FILTER); \
        getsetmacro(L"ShowSuperHidden", fShowSuperHidden, SSF_SHOWSUPERHIDDEN); \
        getsetmacro(L"NoNetCrawling", fNoNetCrawling, SSF_NONETCRAWLING); \
        getsetmacro(L"SeparateProcess", fSepProcess, SSF_SEPPROCESS); \
        getsetmacro(L"AutoCheckSelect", fAutoCheckSelect, ssf_autocheckselect); \
        getsetmacro(L"IconsOnly", fIconsOnly, ssf_iconsonly); \
        getsetmacro(L"ShowTypeOverlay", fShowTypeOverlay, ssf_showtypeoverlay); \
        getsetmacro(L"ShowStatusBar", fShowStatusBar, ssf_showstatusbar); \
    } while (0)
 
    if (bSet)
    {
        DWORD changed = 0, notcached = ~g_CachedSSF & SSF_IMPLEMENTED;
        if (notcached & ~dwMask)
        {
            // All entries in gpss have to be initialized (except the item we are about to set) because we are about to write the whole struct to the registry
            SHELLSTATE tempstate;
            SHGetSetSettings(&tempstate, notcached & ~dwMask, FALSE); // Read entries that are not in gpss/g_CachedSSF
        }
 
#define SHGSS_WriteAdv(name, value, SSF) \
    do { \
        DWORD val = (value), cb = sizeof(DWORD); \
        if (SHSetValueW(hKeyAdv, NULL, (name), REG_DWORD, &val, cb) == ERROR_SUCCESS) \
        { \
            ++changed; \
        } \
    } while (0)
#define SHGSS_SetAdv(name, field, SSF) \
    do { \
        if ((dwMask & (SSF)) && gpss->field != lpss->field) \
        { \
            const DWORD bitval = (gpss->field = lpss->field); \
            SHGSS_WriteAdv((name), ((SSF) & inverted) ? !bitval : !!bitval, (SSF)); \
        } \
    } while (0)
#define SHGSS_SetStruct(field, SSF) \
    do { \
        if ((dwMask & (SSF)) && gpss->field != lpss->field) \
        { \
            gpss->field = lpss->field; \
            ++changed; \
        } \
    } while (0)
 
        if ((dwMask & SSF_SHOWALLOBJECTS) && gpss->fShowAllObjects != lpss->fShowAllObjects)
        {
            gpss->fShowAllObjects = lpss->fShowAllObjects;
            SHGSS_WriteAdv(L"Hidden", lpss->fShowAllObjects ? 1 : 2, SSF_SHOWALLOBJECTS);
        }
        SHGSS_SetStruct(fShowSysFiles, SSF_SHOWSYSFILES);
        SHGSS_GetSetAdv(SHGSS_SetAdv);
        SHGSS_GetSetStruct(SHGSS_SetStruct);
        if (changed)
        {
            if ((dwMask & SSF_SHOWSUPERHIDDEN) && (DLL_EXPORT_VERSION) < _WIN32_WINNT_VISTA)
            {
                // This is probably a Windows bug but write this alternative name just in case someone reads it
                DWORD val = gpss->fShowSuperHidden != FALSE;
                SHSetValueW(hKeyAdv, NULL, L"SuperHidden", REG_DWORD, &val, sizeof(val));
            }
            SHELL32_WriteRegShellState(&g_ShellState); // Write the new SHELLSTATE
            SHGetSetSettings(NULL, 0, TRUE); // Invalidate counter
            SHSendMessageBroadcastW(WM_SETTINGCHANGE, 0, (LPARAM)L"ShellState"); // Notify everyone
        }
    }
    else
    {
        DWORD read = 0, data, cb, dummy = 0;
        DBG_UNREFERENCED_LOCAL_VARIABLE(dummy);
        if (SHELL_GlobalCounterChanged(&g_ShellStateCounter, SHELL_GCOUNTER_SHELLSTATE))
            g_CachedSSF = 0;
 
#define SHGSS_ReadAdv(name, SSF) ( \
    (g_CachedSSF & (SSF)) != (SSF) && (cb = sizeof(DWORD)) != 0 && \
    SHQueryValueEx(hKeyAdv, (name), NULL, NULL, &data, &cb) == ERROR_SUCCESS && \
    cb == sizeof(DWORD) && (read |= (SSF)) != 0 )
#define SHGSS_GetFieldHelper(field, SSF, src, dst, cachevar) \
    do { \
        if (dwMask & (SSF)) \
        { \
            (dst)->field = (src)->field; \
            cachevar |= (SSF); \
        } \
    } while (0)
#define SHGSS_CacheField(field, SSF) SHGSS_GetFieldHelper(field, (SSF), &rss.ss, gpss, read)
#define SHGSS_GetField(field, SSF) SHGSS_GetFieldHelper(field, (SSF), gpss, lpss, dummy)
#define SHGSS_GetAdv(name, field, SSF) \
    do { \
        if (SHGSS_ReadAdv((name), (SSF))) \
            gpss->field = ((SSF) & inverted) ? data == FALSE : data != FALSE; \
        SHGSS_GetFieldHelper(field, (SSF), gpss, lpss, read); \
    } while (0)
 
        if (SHGSS_ReadAdv(L"Hidden", SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES))
        {
            gpss->fShowAllObjects = data == 1;
            gpss->fShowSysFiles = data > 1;
        }
        SHGSS_GetField(fShowAllObjects, SSF_SHOWALLOBJECTS);
        SHGSS_GetField(fShowSysFiles, SSF_SHOWSYSFILES);
        SHGSS_GetSetAdv(SHGSS_GetAdv);
        if (dwMask & ~(read | g_CachedSSF))
        {
            REGSHELLSTATE rss;
            if (SHELL32_ReadRegShellState(&rss))
            {
                SHGSS_GetSetStruct(SHGSS_CacheField); // Copy the requested items to gpss
            }
            else
            {
                SHELL32_GetDefaultShellState(gpss);
                read = 0; // The advanced items we read are no longer valid in gpss
                g_CachedSSF = SSF_STRUCTONLY;
                /* HACKFIX: This should not be needed. Defaults should be used
                 * until an override option is selected. See CORE-20585. */
                rss.ss = *gpss;
                SHELL32_WriteRegShellState(&rss);
            }
        }
        SHGSS_GetSetStruct(SHGSS_GetField); // Copy requested items from gpss to output
        g_CachedSSF |= read;
    }
    if (hKeyAdv)
        RegCloseKey(hKeyAdv);
#else
  if(bSet)
  {
    FIXME("%p 0x%08x TRUE\n", lpss, dwMask);
  }
  else
  {
    SHGetSettings((LPSHELLFLAGSTATE)lpss,dwMask);
  }
#endif //__REACTOS__
}

Referenced by DesktopOnInitDialog(), CDefView::FillList(), GeneralDlg_OnInitDialog(), CDefView::GetItemActivateFlags(), CShellDispatch::GetSetting(), IntSetShellStateSettings(), CStartMenuSettingsPage::OnApply(), ReadCabinetState(), RecycleBinDlg(), CACListISF::Reset(), SHELL_GetDefaultFolderEnumSHCONTF(), SHGetSetSettings(), SHGetSettings(), SHShouldShowWizards(), START_TEST(), and ViewDlg_Apply().

SHGetSettings()

VOID WINAPI SHGetSettings	(	LPSHELLFLAGSTATE	lpsfs,
		DWORD	dwMask
	)

Definition at line 420 of file shellord.c.

{
#ifdef __REACTOS__
    SHELLSTATE ss;
    SHGetSetSettings(&ss, dwMask & ~(SSF_SORTCOLUMNS | SSF_FILTER), FALSE);
    *lpsfs = *(LPSHELLFLAGSTATE)&ss;
    if (dwMask & SSF_HIDEICONS)
        lpsfs->fHideIcons = ss.fHideIcons;
    if (dwMask & ssf_autocheckselect)
        lpsfs->fAutoCheckSelect = ss.fAutoCheckSelect;
    if (dwMask & ssf_iconsonly)
        lpsfs->fIconsOnly = ss.fIconsOnly;
#else
    HKEY    hKey;
    DWORD   dwData;
    DWORD   dwDataSize = sizeof (DWORD);
 
    TRACE("(%p 0x%08x)\n",lpsfs,dwMask);
 
    if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
                 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
      return;
 
    if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
      lpsfs->fShowExtensions  = ((dwData == 0) ?  0 : 1);
 
    if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
      lpsfs->fShowInfoTip  = ((dwData == 0) ?  0 : 1);
 
    if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
      lpsfs->fDontPrettyPath  = ((dwData == 0) ?  0 : 1);
 
    if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
      lpsfs->fHideIcons  = ((dwData == 0) ?  0 : 1);
 
    if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
      lpsfs->fMapNetDrvBtn  = ((dwData == 0) ?  0 : 1);
 
    if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
      lpsfs->fShowAttribCol  = ((dwData == 0) ?  0 : 1);
 
    if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
    { if (dwData == 0)
      { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
        if (SSF_SHOWSYSFILES & dwMask)  lpsfs->fShowSysFiles  = 0;
      }
      else if (dwData == 1)
      { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 1;
        if (SSF_SHOWSYSFILES & dwMask)  lpsfs->fShowSysFiles  = 0;
      }
      else if (dwData == 2)
      { if (SSF_SHOWALLOBJECTS & dwMask)    lpsfs->fShowAllObjects  = 0;
        if (SSF_SHOWSYSFILES & dwMask)  lpsfs->fShowSysFiles  = 1;
      }
    }
    RegCloseKey (hKey);
#endif //__REACTOS__
    TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
}

Referenced by SHGetSetSettings(), and START_TEST().

SHHandleUpdateImage()

INT WINAPI SHHandleUpdateImage

(

PCIDLIST_ABSOLUTE

pidlExtra

)

Definition at line 2668 of file shellord.c.

{
#ifdef __REACTOS__
    if (!pidlExtra)
        return -1;
 
    UNALIGNED const SHCNF_UPDATEIMAGE_DATA_2* pData =
        (UNALIGNED const SHCNF_UPDATEIMAGE_DATA_2*)pidlExtra;
    if (pData->dwProcessId == GetCurrentProcessId())
        return pData->iEffectiveImageIndex;
 
    WCHAR szHashItem[MAX_PATH];
    StrCpyNW(szHashItem, pData->szHashItem, _countof(szHashItem));
 
    return SHLookupIconIndexW(szHashItem, pData->iIndex, pData->uFlags);
#else
    FIXME("%p - stub\n", pidlExtra);
 
    return -1;
#endif
}

SHLimitInputEdit()

HRESULT WINAPI SHLimitInputEdit	(	HWND	hWnd,
		IShellFolder *	psf
	)

Definition at line 3222 of file shellord.c.

{
    IItemNameLimits *pLimits;
    HRESULT hr;
    LPWSTR pwszValidChars, pwszInvalidChars;
    UxSubclassInfo *pInfo;
 
    pInfo = GetPropW(hWnd, L"UxSubclassInfo");
    if (pInfo)
    {
        UxSubclassInfo_Destroy(pInfo);
        pInfo = NULL;
    }
 
    hr = psf->lpVtbl->QueryInterface(psf, &IID_IItemNameLimits, (LPVOID *)&pLimits);
    if (FAILED(hr))
    {
        ERR("hr: %x\n", hr);
        return hr;
    }
 
    pwszValidChars = pwszInvalidChars = NULL;
    hr = pLimits->lpVtbl->GetValidCharacters(pLimits, &pwszValidChars, &pwszInvalidChars);
    if (FAILED(hr))
    {
        ERR("hr: %x\n", hr);
        pLimits->lpVtbl->Release(pLimits);
        return hr;
    }
 
    pInfo = UxSubclassInfo_Create(hWnd, pwszValidChars, pwszInvalidChars);
    if (!pInfo)
        hr = E_FAIL;
 
    pLimits->lpVtbl->Release(pLimits);
 
    return hr;
}

Referenced by DialogProc(), DoNullFolderTest(), CDefView::OnNotify(), START_TEST(), and test_SHLimitInputEdit().

SHLoadOLE()

HRESULT WINAPI SHLoadOLE

(

LPARAM

lParam

)

Definition at line 2029 of file shellord.c.

{   FIXME("0x%08lx stub\n",lParam);
    return S_OK;
}

SHObjectProperties()

BOOL WINAPI SHObjectProperties	(	HWND	hwnd,
		DWORD	dwType,
		LPCWSTR	szObject,
		LPCWSTR	szPage
	)

Definition at line 2690 of file shellord.c.

{
    LPITEMIDLIST pidl = NULL;
    switch (dwType)
    {
        case SHOP_FILEPATH:
            pidl = ILCreateFromPathW(szObject);
            break;
    }
    if (pidl)
    {
        SHELLEXECUTEINFOW sei = { sizeof(sei), SEE_MASK_INVOKEIDLIST, hwnd, L"properties",
                                  NULL, szPage, NULL, SW_SHOWNORMAL, NULL, pidl };
        BOOL result = ShellExecuteExW(&sei);
        ILFree(pidl);
        return result;
    }
 
    FIXME("%p, 0x%08x, %s, %s - stub\n", hwnd, dwType, debugstr_w(szObject), debugstr_w(szPage));
 
    return TRUE;
}

SHOutOfMemoryMessageBox()

int WINAPI SHOutOfMemoryMessageBox	(	HWND	hwndOwner,
		LPCSTR	lpCaption,
		UINT	uType
	)

Definition at line 2064 of file shellord.c.

{
    FIXME("%p %s 0x%08x stub\n",hwndOwner, lpCaption, uType);
    return 0;
}

SHRegisterDragDrop()

HRESULT WINAPI SHRegisterDragDrop	(	HWND	hWnd,
		LPDROPTARGET	pDropTarget
	)

Definition at line 750 of file shellord.c.

{
        static BOOL ole_initialized = FALSE;
        HRESULT hr;
 
        TRACE("(%p,%p)\n", hWnd, pDropTarget);
 
        if (!ole_initialized)
        {
            hr = OleInitialize(NULL);
            if (FAILED(hr))
                return hr;
            ole_initialized = TRUE;
        }
    return RegisterDragDrop(hWnd, pDropTarget);
}

SHReplaceFromPropSheetExtArray()

UINT WINAPI SHReplaceFromPropSheetExtArray	(	HPSXA	hpsxa,
		UINT	uPageID,
		LPFNADDPROPSHEETPAGE	lpfnReplaceWith,
		LPARAM	lParam
	)

Definition at line 2473 of file shellord.c.

{
    PSXA_CALL Call;
    UINT i;
    PPSXA psxa = (PPSXA)hpsxa;
 
    TRACE("(%p,%u,%p,%08lx)\n", hpsxa, uPageID, lpfnReplaceWith, lParam);
 
    if (psxa)
    {
        ZeroMemory(&Call, sizeof(Call));
        Call.lpfnAddReplaceWith = lpfnReplaceWith;
        Call.lParam = lParam;
 
        /* Call the ReplacePage method of all registered IShellPropSheetExt interfaces.
           Each shell extension is only allowed to call the callback once during the callback. */
        for (i = 0; i != psxa->uiCount; i++)
        {
            Call.bCalled = FALSE;
            psxa->pspsx[i]->lpVtbl->ReplacePage(psxa->pspsx[i], uPageID, PsxaCall, (LPARAM)&Call);
        }
 
        return Call.uiCount;
    }
 
    return 0;
}

Referenced by DisplayApplet(), and MouseApplet().

SHRevokeDragDrop()

HRESULT WINAPI SHRevokeDragDrop

(

HWND

hWnd

)

Definition at line 785 of file shellord.c.

{
    TRACE("(%p)\n", hWnd);
    return RevokeDragDrop(hWnd);
}

SHRunControlPanel()

BOOL WINAPI SHRunControlPanel	(	_In_ LPCWSTR	commandLine,
		_In_opt_ HWND	parent
	)

Definition at line 1696 of file shellord.c.

{
#ifdef __REACTOS__
    TRACE("(%s, %p)n", debugstr_w(commandLine), parent);
    /* MSDN indicates that ROS should have a version check here but Vista+ just forwards to SHUNIMPL
    if (LOBYTE(GetVersion()) >= 6)
        return FALSE;
    */
    return SHELL32_RunControlPanel(commandLine, parent);
#else
    FIXME("(%s, %p): stub\n", debugstr_w(commandLine), parent);
    return FALSE;
#endif
}

SHSetInstanceExplorer()

VOID WINAPI SHSetInstanceExplorer

(

LPUNKNOWN

lpUnknown

)

Definition at line 1718 of file shellord.c.

{   TRACE("%p\n", lpUnknown);
    SHELL32_IExplorerInterface = lpUnknown;
}

Referenced by SHCreateFromDesktop(), ExplorerInstance::Wait(), and wmain().

SHSetLocalizedName()

HRESULT WINAPI SHSetLocalizedName	(	LPCWSTR	pszPath,
		LPCWSTR	pszResModule,
		int	idsRes
	)

Definition at line 2797 of file shellord.c.

{
    FIXME("%p, %s, %d - stub\n", pszPath, debugstr_w(pszResModule), idsRes);
 
    return S_OK;
}

SHShellFolderView_Message()

LRESULT WINAPI SHShellFolderView_Message	(	HWND	hwndCabinet,
		UINT	uMessage,
		LPARAM	lParam
	)

Definition at line 500 of file shellord.c.

{
    FIXME("%p %08x %08lx stub\n",hwndCabinet, uMessage, lParam);
    return 0;
}

SHStartNetConnectionDialog()

HRESULT WINAPI SHStartNetConnectionDialog	(	HWND	hwnd,
		LPCSTR	pszRemoteName,
		DWORD	dwType
	)

Definition at line 2780 of file shellord.c.

{
#ifdef __REACTOS__
    if (SHELL_OsIsUnicode())
        return SHStartNetConnectionDialogW(hwnd, (LPCWSTR)pszRemoteName, dwType);
    return SHStartNetConnectionDialogA(hwnd, pszRemoteName, dwType);
#else
    FIXME("%p, %s, 0x%08x - stub\n", hwnd, debugstr_a(pszRemoteName), dwType);
 
    return S_OK;
#endif
}

SHTestTokenMembership()

EXTERN_C BOOL WINAPI SHTestTokenMembership	(	HANDLE	TokenHandle,
		ULONG	ulRID
	)

Definition at line 2930 of file shellord.c.

{
    SID_IDENTIFIER_AUTHORITY ntAuth = {SECURITY_NT_AUTHORITY};
    DWORD nSubAuthority0, nSubAuthority1;
    DWORD nSubAuthorityCount;
    PSID SidToCheck;
    BOOL IsMember = FALSE;
 
    if ((ulRID == SECURITY_SERVICE_RID) || ulRID == SECURITY_LOCAL_SYSTEM_RID)
    {
        nSubAuthority0 = ulRID;
        nSubAuthority1 = 0;
        nSubAuthorityCount= 1;
    }
    else
    {
        nSubAuthority0 = SECURITY_BUILTIN_DOMAIN_RID;
        nSubAuthority1 = ulRID;
        nSubAuthorityCount= 2;
    }
 
    if (!AllocateAndInitializeSid(&ntAuth,
                                  nSubAuthorityCount,
                                  nSubAuthority0,
                                  nSubAuthority1,
                                  0, 0, 0, 0, 0, 0,
                                  &SidToCheck))
    {
        return FALSE;
    }
 
    if (!CheckTokenMembership(TokenHandle, SidToCheck, &IsMember))
    {
        IsMember = FALSE;
    }
 
    FreeSid(SidToCheck);
    return IsMember;
}

Referenced by IsUserAnAdmin().

SHUpdateImageA()

VOID WINAPI SHUpdateImageA	(	LPCSTR	pszHashItem,
		INT	iIndex,
		UINT	uFlags,
		INT	iImageIndex
	)

Definition at line 2650 of file shellord.c.

{
#ifdef __REACTOS__
    WCHAR szHashItem[MAX_PATH];
    SHAnsiToUnicode(pszHashItem, szHashItem, _countof(szHashItem));
    SHUpdateImageW(szHashItem, iIndex, uFlags, iImageIndex);
#else
    FIXME("%s, %d, 0x%x, %d - stub\n", debugstr_a(pszHashItem), iIndex, uFlags, iImageIndex);
#endif
}

SHUpdateImageW()

void WINAPI SHUpdateImageW	(	LPCWSTR	pszHashItem,
		int	iIndex,
		UINT	uFlags,
		int	iImageIndex
	)

Definition at line 2610 of file shellord.c.

{
#ifdef __REACTOS__
    // If iImageIndex == -1 (undetermined), it will fall back to the default value of 1.
    INT iEffectiveImageIndex = (iImageIndex == -1) ? 1 : iImageIndex;
 
    SHCNF_UPDATEIMAGE_DATA_1 item1;
    item1.cbSize      = sizeof(item1);
    item1.iIndex      = iIndex;
    item1.iEffective  = iEffectiveImageIndex;
    item1.uFlags      = uFlags;
    item1.iEffective2 = iEffectiveImageIndex;
    item1.terminator  = 0;
 
    SHCNF_UPDATEIMAGE_DATA_2 item2;
 
    LPWSTR pEnd = StrCpyNXW(item2.szHashItem, pszHashItem, _countof(item2.szHashItem));
    *pEnd = UNICODE_NULL;
 
    item2.cbOffset             = (WORD)((PBYTE)pEnd - (PBYTE)&item2);
    item2.iIndex               = iIndex;
    item2.iEffectiveImageIndex = iEffectiveImageIndex;
    item2.uFlags               = uFlags;
    item2.dwProcessId          = GetCurrentProcessId();
    item2.terminator           = 0;
 
    SHChangeNotify(SHCNE_UPDATEIMAGE, SHCNF_IDLIST, &item1, &item2);
#else
    FIXME("%s, %d, 0x%x, %d - stub\n", debugstr_w(pszHashItem), iIndex, uFlags, iImageIndex);
#endif
}

Referenced by SHUpdateImageA().

SHValidateUNC()

BOOL WINAPI SHValidateUNC	(	HWND	hwndOwner,
		PWSTR	pszFile,
		UINT	fConnect
	)

Definition at line 2108 of file shellord.c.

{
    FIXME("(%p, %s, 0x%08x): stub\n", hwndOwner, debugstr_w(pszFile), fConnect);
    return FALSE;
}

SHWaitForFileToOpen()

BOOL WINAPI SHWaitForFileToOpen	(	LPCITEMIDLIST	pidl,
		DWORD	dwFlags,
		DWORD	dwTimeout
	)

Definition at line 2085 of file shellord.c.

{
    FIXME("%p 0x%08x 0x%08x stub\n", pidl, dwFlags, dwTimeout);
    return FALSE;
}

SHWinHelp()

HRESULT WINAPI SHWinHelp	(	HWND	hwnd,
		LPCWSTR	pszHelp,
		UINT	uCommand,
		ULONG_PTR	dwData
	)

Definition at line 1656 of file shellord.c.

{
    TRACE("(%p, %s, 0x%08x, %p)\n", hwnd, debugstr_w(pszHelp), uCommand, dwData);
    if (!WinHelpW(hwnd, pszHelp, uCommand, dwData))
    {
#if 0
        ShellMessageBoxW(shell32_hInstance, hwnd, MAKEINTRESOURCEW(9115),
                         MAKEINTRESOURCEW(9116), MB_ICONSTOP);
#endif
        return FALSE;
    }
    return TRUE;
}

SignalFileOpen()

BOOL WINAPI SignalFileOpen

(

PCIDLIST_ABSOLUTE

pidl

)

Definition at line 836 of file shellord.c.

{
    FIXME("(%p):stub.\n", pidl);
 
    return FALSE;
}

UxSubclassInfo_Create()

static UxSubclassInfo * UxSubclassInfo_Create ( HWND  hwnd, LPWSTR  valid, LPWSTR  invalid  )

static

Definition at line 3188 of file shellord.c.

{
    UxSubclassInfo *pInfo;
    pInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(UxSubclassInfo));
    if (!pInfo)
    {
        ERR("HeapAlloc failed.\n");
        CoTaskMemFree(valid);
        CoTaskMemFree(invalid);
        return NULL;
    }
 
    pInfo->fnWndProc = (WNDPROC)SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (LONG_PTR)LimitEditWindowProc);
    if (!pInfo->fnWndProc)
    {
        ERR("SetWindowLongPtrW failed\n");
        CoTaskMemFree(valid);
        CoTaskMemFree(invalid);
        HeapFree(GetProcessHeap(), 0, pInfo);
        return NULL;
    }
 
    pInfo->hwnd = hwnd;
    pInfo->pwszValidChars = valid;
    pInfo->pwszInvalidChars = invalid;
    if (!SetPropW(hwnd, L"UxSubclassInfo", pInfo))
    {
        UxSubclassInfo_Destroy(pInfo);
        pInfo = NULL;
    }
    return pInfo;
}

Referenced by SHLimitInputEdit().

UxSubclassInfo_Destroy()

static void UxSubclassInfo_Destroy ( UxSubclassInfo *  pInfo )

static

Definition at line 3002 of file shellord.c.

{
    if (!pInfo)
        return;
 
    RemovePropW(pInfo->hwnd, L"UxSubclassInfo");
 
    CoTaskMemFree(pInfo->pwszValidChars);
    CoTaskMemFree(pInfo->pwszInvalidChars);
 
    SetWindowLongPtrW(pInfo->hwnd, GWLP_WNDPROC, (LONG_PTR)pInfo->fnWndProc);
 
    HeapFree(GetProcessHeap(), 0, pInfo);
}

Referenced by LimitEditWindowProc(), SHLimitInputEdit(), and UxSubclassInfo_Create().

WINE_DECLARE_DEBUG_CHANNEL()

WINE_DECLARE_DEBUG_CHANNEL

(

pidl

)

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)

WriteCabinetState()

BOOL WINAPI WriteCabinetState

(

CABINETSTATE *

cs

)

Definition at line 1967 of file shellord.c.

{
    DWORD r;
    HKEY hkey = 0;
 
    TRACE("%p\n",cs);
 
    if( cs == NULL )
        return FALSE;
 
    r = RegCreateKeyExW( HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CabinetState", 0,
         NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
    if( r == ERROR_SUCCESS )
    {
        r = RegSetValueExW( hkey, L"Settings", 0,
            REG_BINARY, (LPBYTE) cs, cs->cLength);
 
        RegCloseKey( hkey );
    }
 
#ifdef __REACTOS__
    /* TODO: if (r==ERROR_SUCCESS) Increment GLOBALCOUNTER_FOLDERSETTINGSCHANGE */
#endif
    return (r==ERROR_SUCCESS);
}

Referenced by IntSetNewWindowMode(), and ViewDlg_Apply().

Variable Documentation

DAD_bDragging

BOOL DAD_bDragging = FALSE

static

Definition at line 78 of file shellord.c.

Referenced by DAD_DragEnterEx(), DAD_DragLeave(), DAD_DragMove(), DAD_SetDragImage(), and DAD_ShowDragImage().

DAD_himlTrack

HIMAGELIST DAD_himlTrack = NULL

static

Definition at line 76 of file shellord.c.

Referenced by DAD_DragEnterEx(), and DAD_SetDragImage().

DAD_ptHotspot

POINT DAD_ptHotspot

static

Definition at line 77 of file shellord.c.

Referenced by DAD_DragEnterEx(), and DAD_SetDragImage().

SHELL32_IExplorerInterface

LPUNKNOWN SHELL32_IExplorerInterface =0

static

Definition at line 1711 of file shellord.c.

Referenced by SHGetInstanceExplorer(), and SHSetInstanceExplorer().