You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2038 lines
58 KiB
2038 lines
58 KiB
/*****************************************************************************
|
|
*
|
|
* DISubCls.c
|
|
*
|
|
* Copyright (c) 1996 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* Abstract:
|
|
*
|
|
* "Safe subclassing" code, stolen from comctl32.
|
|
*
|
|
* Originally written by francish. Stolen by raymondc.
|
|
*
|
|
* Contents:
|
|
*
|
|
* SetWindowSubclass
|
|
* GetWindowSubclass
|
|
* RemoveWindowSubclass
|
|
* DefSubclassProc
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "dinputpr.h"
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* The sqiffle for this file.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#define sqfl sqflSubclass
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @topic DirectInput Subclassing |
|
|
*
|
|
*
|
|
* This module defines helper functions that make subclassing windows safe(er)
|
|
* and easy(er). The code maintains a single property on the subclassed window
|
|
* and dispatches various "subclass callbacks" to its clients a required. The
|
|
* client is provided reference data and a simple "default processing" API.
|
|
*
|
|
* Semantics:
|
|
* A "subclass callback" is identified by a unique pairing of a callback
|
|
* function pointer and an unsigned ID value. Each callback can also store a
|
|
* single DWORD of reference data, which is passed to the callback function
|
|
* when it is called to filter messages. No reference counting is performed
|
|
* for the callback, it may repeatedly call the SetWindowSubclass API to alter
|
|
* the value of its reference data element as desired.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct SUBCLASS_CALL |
|
|
*
|
|
* Structure which tracks a single subclassing client.
|
|
*
|
|
* Although a linked list would have made the code slightly
|
|
* simpler, this module uses a packed callback array to avoid
|
|
* unneccessary fragmentation.
|
|
*
|
|
* @field SUBCLASSPROC | pfnSubclass |
|
|
*
|
|
* The subclass procedure. If this is zero, it means that
|
|
* the node is dying and should be ignored.
|
|
*
|
|
* @field UINT | uIdSubclass |
|
|
*
|
|
* Unique subclass identifier.
|
|
*
|
|
* @field DWORD | dwRefData |
|
|
*
|
|
* Optional reference data for subclass procedure.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct SUBCLASS_CALL {
|
|
SUBCLASSPROC pfnSubclass;
|
|
UINT_PTR uIdSubclass;
|
|
ULONG_PTR dwRefData;
|
|
} SUBCLASS_CALL, *PSUBCLASS_CALL;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct SUBCLASS_FRAME |
|
|
*
|
|
* Structure which tracks the state of an active call to the
|
|
* window's window procedure.
|
|
*
|
|
* Each time the window procedure is entered, we create a new
|
|
* <t SUBCLASS_FRAME>, which remains active until the last
|
|
* subclass procedure returns, at which point the frame is
|
|
* torn down.
|
|
*
|
|
* The subclass frames are stored on the stack. So walking
|
|
* the frame chain causes you to wander through the stack.
|
|
*
|
|
* @field UINT | uCallIndex |
|
|
*
|
|
* Index of next callback to call.
|
|
*
|
|
* @field UINT | uDeepestCall |
|
|
*
|
|
* Deepest <e SUBCLASS_FRAME.uCallIndex> on the stack.
|
|
*
|
|
* @field SUBCLASS_FRAME * | pFramePrev |
|
|
*
|
|
* The previous subclass frame.
|
|
*
|
|
* @field PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* The header associated with this frame.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct SUBCLASS_FRAME {
|
|
UINT uCallIndex;
|
|
UINT uDeepestCall;
|
|
struct SUBCLASS_FRAME *pFramePrev;
|
|
struct SUBCLASS_HEADER *pHeader;
|
|
} SUBCLASS_FRAME, *PSUBCLASS_FRAME;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @struct SUBCLASS_HEADER |
|
|
*
|
|
* Structure which tracks the subclass goo associated with
|
|
* a window. A pointer to this structure is kept in a private
|
|
* window property.
|
|
*
|
|
* @field UINT | uRefs |
|
|
*
|
|
* Subclass count. This is the number of valid entries
|
|
* in the <p CallArray>.
|
|
*
|
|
* @field UINT | uAlloc |
|
|
*
|
|
* Number of allocated <t SUBCLASS_CALL> nodes in the array.
|
|
*
|
|
* @field UINT | uCleanup |
|
|
*
|
|
* Index of the call node to clean up.
|
|
*
|
|
* @field WORD | dwThreadId |
|
|
*
|
|
* Thread id of the window with which the structure is associated.
|
|
*
|
|
* @field PSUBCLASS_FRAME | pFrameCur |
|
|
*
|
|
* Pointer to the current subclass frame.
|
|
*
|
|
* @field SUBCLASS_CALL | CallArray[1] |
|
|
*
|
|
* Base of the packed call node array.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
typedef struct SUBCLASS_HEADER {
|
|
UINT uRefs;
|
|
UINT uAlloc;
|
|
UINT uCleanup;
|
|
DWORD dwThreadId;
|
|
PSUBCLASS_FRAME pFrameCur;
|
|
SUBCLASS_CALL CallArray[1];
|
|
} SUBCLASS_HEADER, *PSUBCLASS_HEADER;
|
|
|
|
#define CALLBACK_ALLOC_GRAIN (3) /* 1 defproc, 1 subclass, 1 spare */
|
|
|
|
LRESULT CALLBACK
|
|
MasterSubclassProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp);
|
|
|
|
|
|
LRESULT INTERNAL
|
|
CallNextSubclassProc(PSUBCLASS_HEADER pHeader, HWND hwnd, UINT wm,
|
|
WPARAM wp, LPARAM lp);
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LRESULT | SubclassDeath |
|
|
*
|
|
* This function is called if we ever enter one of our subclassing
|
|
* procedures without our reference data (and hence without the
|
|
* previous <t WNDPROC>).
|
|
*
|
|
* Hitting this represents a catastrophic failure in the
|
|
* subclass code.
|
|
*
|
|
* The function resets the <t WNDPROC> of the window to
|
|
* <f DefWindowProc> to avoid faulting.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window that just got hosed.
|
|
*
|
|
* @parm UINT | wm |
|
|
*
|
|
* Window message that caused us to realize that we are hosed.
|
|
*
|
|
* @parm WPARAM | wp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
* @parm LPARAM | lp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
|
|
LRESULT INTERNAL
|
|
SubclassDeath(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp)
|
|
{
|
|
/*
|
|
* WE SHOULD NEVER EVER GET HERE
|
|
*/
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl | sqflError,
|
|
TEXT("Fatal! SubclassDeath in window %p"),
|
|
hwnd);
|
|
AssertF(0);
|
|
|
|
/*
|
|
* We call the outside world, so we'd better not have the critsec.
|
|
*/
|
|
AssertF(!InCrit());
|
|
|
|
/*
|
|
* In theory, we could save the original WNDPROC in a separate property,
|
|
* but that just wastes memory for something that should never happen.
|
|
*/
|
|
#ifdef WINNT
|
|
SetWindowLongPtr( hwnd, GWLP_WNDPROC, (LONG_PTR)(DefWindowProc));
|
|
#else
|
|
SubclassWindow(hwnd, DefWindowProc);
|
|
#endif
|
|
|
|
return DefWindowProc(hwnd, wm, wp, lp);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func WNDPROC | GetWindowProc |
|
|
*
|
|
* Returns the <t WNDPROC> of the specified window.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window to be inspected.
|
|
*
|
|
* @returns
|
|
*
|
|
* The <t WNDPROC> of the specified window.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
WNDPROC INLINE
|
|
GetWindowProc(HWND hwnd)
|
|
{
|
|
#ifdef WINNT
|
|
return (WNDPROC)GetWindowLongPtr(hwnd, GWLP_WNDPROC);
|
|
#else
|
|
return (WNDPROC)GetWindowLong(hwnd, GWL_WNDPROC);
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @global ATOM | g_atmDISubclass |
|
|
*
|
|
* This is the global <t ATOM> we use to store our
|
|
* <t SUBCLASS_HEADER> property on whatever windows come our way.
|
|
*
|
|
* If the <p WIN95_HACK> symbol is defined, then we will work
|
|
* around a bug in Windows 95 where Windows "helpfully"
|
|
* <f GlobalDeleteAtom>'s all properties that are on a window
|
|
* when the window dies. See Francis's original explanation
|
|
* in subclass.c.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#pragma BEGIN_CONST_DATA
|
|
|
|
TCHAR c_tszDISubclass[] = TEXT("DirectInputSubclassInfo");
|
|
|
|
#pragma END_CONST_DATA
|
|
|
|
#ifdef WIN95_HACK
|
|
ATOM g_atmDISubclass;
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func PSUBCLASS_HEADER | FastGetSubclassHeader |
|
|
*
|
|
* Obtains the <t SUBCLASS_HEADER> for the specified window.
|
|
*
|
|
* This function succeeds on any thread, although the value
|
|
* is meaningless from the wrong process.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @returns
|
|
*
|
|
* Pointer to the <t SUBCLASS_HEADER> associated with the window,
|
|
* or <c NULL> if the window is not subclassed by us.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
PSUBCLASS_HEADER INLINE
|
|
FastGetSubclassHeader(HWND hwnd)
|
|
{
|
|
#ifdef WIN95_HACK
|
|
/*
|
|
* The right thing happens if g_atmDISubclass is 0, namely,
|
|
* the property is not found. Unfortunately, NT RIPs when
|
|
* you do this, so we'll be polite and not RIP.
|
|
*/
|
|
if (g_atmDISubclass) {
|
|
return (PSUBCLASS_HEADER)GetProp(hWnd, (PV)g_atmDISubclass);
|
|
} else {
|
|
return 0;
|
|
}
|
|
#else
|
|
return (PSUBCLASS_HEADER)GetProp(hwnd, c_tszDISubclass);
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func PSUBCLASS_HEADER | GetSubclassHeader |
|
|
*
|
|
* Obtains the <t SUBCLASS_HEADER> for the specified window.
|
|
* It fails if the caller is in the wrong process, but will
|
|
* allow the caller to get the header from a different thread.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @returns
|
|
*
|
|
* Pointer to the <t SUBCLASS_HEADER> associated with the window,
|
|
* or <c NULL> if the window is not subclass by us yet, or 1
|
|
* if it belongs to another process.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
PSUBCLASS_HEADER INTERNAL
|
|
GetSubclassHeader(HWND hwnd)
|
|
{
|
|
DWORD idProcess;
|
|
|
|
/*
|
|
* Make sure we're in the right process.
|
|
*
|
|
* Must use our helper function to catch bad scenarios like
|
|
* the goofy Windows 95 console window which lies about its
|
|
* owner.
|
|
*/
|
|
|
|
idProcess = GetWindowPid(hwnd);
|
|
|
|
if (idProcess == GetCurrentProcessId()) { /* In the right process */
|
|
return FastGetSubclassHeader(hwnd);
|
|
} else {
|
|
if (idProcess) {
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl | sqflError,
|
|
TEXT("XxxWindowSubclass: ")
|
|
TEXT("wrong process for window %p"), hwnd);
|
|
}
|
|
return (PSUBCLASS_HEADER)1;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL | SetSubclassHeader |
|
|
*
|
|
* Sets the <t SUBCLASS_HEADER> for the specified window.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* The value to set.
|
|
*
|
|
* @parm PSUBCLASS_FRAME | pFrameFixup |
|
|
*
|
|
* The active frames, which need to be walked and fixed up
|
|
* to refer to the new <t SUBCLASS_HEADER>.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL INTERNAL
|
|
SetSubclassHeader(HWND hwnd, PSUBCLASS_HEADER pHeader,
|
|
PSUBCLASS_FRAME pFrameFixup)
|
|
{
|
|
BOOL fRc;
|
|
|
|
AssertF(InCrit()); /* We are partying on the header and frame list */
|
|
|
|
#ifdef WIN95_HACK
|
|
if (g_atmDISubclass == 0) {
|
|
ATOM atm;
|
|
/*
|
|
* HACK: we are intentionally incrementing the refcount on this atom
|
|
* WE DO NOT WANT IT TO GO BACK DOWN so we will not delete it in
|
|
* process detach (see comments for g_atmDISubclass in subclass.c
|
|
* for more info).
|
|
*/
|
|
atm = GlobalAddAtom(c_tszDISubclass);
|
|
if (atm) {
|
|
g_atmDISubclass = atm; /* In case the old atom got nuked */
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Update the frame list if required.
|
|
*/
|
|
while (pFrameFixup) {
|
|
pFrameFixup->pHeader = pHeader;
|
|
pFrameFixup = pFrameFixup->pFramePrev;
|
|
}
|
|
|
|
/*
|
|
* If we have a window to update, then update/remove the property
|
|
* as required.
|
|
*/
|
|
if (hwnd) {
|
|
if (!pHeader) {
|
|
#ifdef WIN95_HACK
|
|
/*
|
|
* HACK: we remove with an ATOM so the refcount won't drop
|
|
* (see comments for g_atmDISubclass above)
|
|
*/
|
|
RemoveProp(hwnd, (PV)g_atmDISubclass);
|
|
#else
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl, TEXT("SetSubclassHeader: Removing %p"),
|
|
pHeader);
|
|
RemoveProp(hwnd, c_tszDISubclass);
|
|
#endif
|
|
fRc = 1;
|
|
} else {
|
|
#ifdef WIN95_HACK
|
|
/*
|
|
* HACK: we add using a STRING so the refcount will go up
|
|
* (see comments for g_atmDISubclass above)
|
|
*/
|
|
#endif
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl, TEXT("SetSubclassHeader: Adding %p"),
|
|
pHeader);
|
|
fRc = SetProp(hwnd, c_tszDISubclass, pHeader);
|
|
if (!fRc) {
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl | sqflError, TEXT("SetWindowSubclass: ")
|
|
TEXT("couldn't subclass window %p"), hwnd);
|
|
}
|
|
}
|
|
} else {
|
|
fRc = 1; /* Weird vacuous success */
|
|
}
|
|
|
|
return fRc;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | FreeSubclassHeader |
|
|
*
|
|
* Toss the subclass header for the specified window.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* The value being tossed.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
FreeSubclassHeader(HWND hwnd, PSUBCLASS_HEADER pHeader)
|
|
{
|
|
AssertF(InCrit()); /* we will be removing the subclass header */
|
|
|
|
/*
|
|
* Sanity checking...
|
|
*/
|
|
if (pHeader) {
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl, TEXT("FreeSubclassHeader: Freeing %p"),
|
|
pHeader);
|
|
SetSubclassHeader(hwnd, 0, pHeader->pFrameCur); /* Clean up the header */
|
|
LocalFree(pHeader);
|
|
} else {
|
|
AssertF(0);
|
|
}
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | ReallocSubclassHeader |
|
|
*
|
|
* Change the size of the subclass header as indicated.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* The current header.
|
|
*
|
|
* @parm UINT | uCallbacks |
|
|
*
|
|
* Desired size.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
PSUBCLASS_HEADER INTERNAL
|
|
ReAllocSubclassHeader(HWND hwnd, PSUBCLASS_HEADER pHeader, UINT uCallbacks)
|
|
{
|
|
UINT uAlloc;
|
|
|
|
AssertF(InCrit()); /* we will be replacing the subclass header */
|
|
|
|
/*
|
|
* Granularize the allocation.
|
|
*/
|
|
uAlloc = CALLBACK_ALLOC_GRAIN *
|
|
((uCallbacks + CALLBACK_ALLOC_GRAIN - 1) / CALLBACK_ALLOC_GRAIN);
|
|
|
|
/*
|
|
* Do we need to change the allocation?
|
|
*/
|
|
if (!pHeader || (uAlloc != pHeader->uAlloc)) {
|
|
/*
|
|
* compute bytes required
|
|
*/
|
|
uCallbacks = uAlloc * sizeof(SUBCLASS_CALL) + sizeof(SUBCLASS_HEADER);
|
|
|
|
/*
|
|
* And try to alloc / realloc.
|
|
*/
|
|
if (SUCCEEDED(ReallocCbPpv(uCallbacks, &pHeader))) {
|
|
/*
|
|
* Update info.
|
|
*/
|
|
pHeader->uAlloc = uAlloc;
|
|
|
|
if (SetSubclassHeader(hwnd, pHeader, pHeader->pFrameCur)) {
|
|
} else {
|
|
FreeSubclassHeader(hwnd, pHeader);
|
|
pHeader = 0;
|
|
}
|
|
} else {
|
|
pHeader = 0;
|
|
}
|
|
}
|
|
|
|
AssertF(pHeader);
|
|
return pHeader;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LRESULT | CallOriginalWndProc |
|
|
*
|
|
* This procedure is the default <t SUBCLASSPROC> which is always
|
|
* installed when we subclass a window. The original window
|
|
* procedure is installed as the reference data for this
|
|
* callback. It simply calls the original <t WNDPROC> and
|
|
* returns its result.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm UINT | wm |
|
|
*
|
|
* Window message that needs to go to the original <t WNDPROC>.
|
|
*
|
|
* @parm WPARAM | wp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
* @parm LPARAM | lp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
* @parm UINT | uIdSubclass |
|
|
*
|
|
* ID number (not used).
|
|
*
|
|
* @parm DWORD | dwRefData |
|
|
*
|
|
* Reference data for subclass procedure (original <t WNDPROC>).
|
|
*
|
|
*****************************************************************************/
|
|
|
|
LRESULT CALLBACK
|
|
CallOriginalWndProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp,
|
|
UINT_PTR uIdSubclass, ULONG_PTR dwRefData)
|
|
{
|
|
/*
|
|
* dwRefData should be the original window procedure
|
|
*/
|
|
AssertF(dwRefData);
|
|
|
|
/*
|
|
* and call it.
|
|
*/
|
|
return CallWindowProc((WNDPROC)dwRefData, hwnd, wm, wp, lp);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func PSUBCLASS_HEADER | AttachSubclassHeader |
|
|
*
|
|
* This procedure makes sure that a given window is subclassed by us.
|
|
* It maintains a reference count on the data structures associated
|
|
* with our subclass. if the window is not yet subclassed by us
|
|
* then this procedure installs our subclass procedure and
|
|
* associated data structures.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
PSUBCLASS_HEADER INTERNAL
|
|
AttachSubclassHeader(HWND hwnd)
|
|
{
|
|
PSUBCLASS_HEADER pHeader;
|
|
|
|
/*
|
|
* We party on the subclass call chain here
|
|
*/
|
|
AssertF(InCrit());
|
|
|
|
/*
|
|
* Yes, we subclass the window out of context, but we are careful
|
|
* to avoid race conditions. There is still a problem if some
|
|
* other DLL tries to un-subclass a window just as we are subclassing
|
|
* it. But there's nothing you can do about it, and besides,
|
|
* what are the odds...?
|
|
*/
|
|
|
|
/*
|
|
* If haven't already subclassed the window then do it now
|
|
*/
|
|
pHeader = GetSubclassHeader(hwnd);
|
|
|
|
if( pHeader == (PSUBCLASS_HEADER)1 )
|
|
{
|
|
/*
|
|
* It's all gone horribly wrong
|
|
* This can happen when the application uses joyXXX functions in Winmm.dll.
|
|
*/
|
|
pHeader = 0;
|
|
}
|
|
else if (pHeader == 0) {
|
|
/*
|
|
* attach our header data to the window
|
|
* we need space for two callbacks:
|
|
* the subclass and the original proc
|
|
*/
|
|
pHeader = ReAllocSubclassHeader(hwnd, 0, 2);
|
|
if (pHeader) {
|
|
SUBCLASS_CALL *pCall;
|
|
|
|
/*
|
|
* Set up the first node in the array to call
|
|
* the original WNDPROC. Do this before subclassing
|
|
* to avoid a race if the window receives a message
|
|
* after we have installed our subclass but before
|
|
* we can save the original WNDPROC.
|
|
*/
|
|
AssertF(pHeader->uAlloc);
|
|
|
|
pCall = pHeader->CallArray;
|
|
pCall->pfnSubclass = CallOriginalWndProc;
|
|
pCall->uIdSubclass = 0;
|
|
pCall->dwRefData = (ULONG_PTR)GetWindowProc(hwnd);
|
|
|
|
/*
|
|
* init our subclass refcount...
|
|
*/
|
|
pHeader->uRefs = 1;
|
|
|
|
pHeader->dwThreadId = GetWindowThreadProcessId(hwnd, NULL);
|
|
|
|
/*
|
|
* Super-paranoid. We must must not race with another
|
|
* instance of ourselves trying to un-subclass.
|
|
*/
|
|
AssertF(InCrit());
|
|
|
|
/*
|
|
* Save the new "old" wndproc in case we raced with
|
|
* somebody else trying to subclass.
|
|
*/
|
|
#ifdef WINNT
|
|
pCall->dwRefData = (ULONG_PTR)SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)MasterSubclassProc);
|
|
#else
|
|
pCall->dwRefData = (DWORD)SubclassWindow(hwnd, MasterSubclassProc);
|
|
#endif
|
|
if (pCall->dwRefData) {
|
|
DllLoadLibrary(); /* Make sure we don't get unloaded */
|
|
} else { /* clean up and get out */
|
|
FreeSubclassHeader(hwnd, pHeader);
|
|
pHeader = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pHeader;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | DetachSubclassHeader |
|
|
*
|
|
* This procedure attempts to detach the subclass header from
|
|
* the specified window.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* Header to detach.
|
|
*
|
|
* @parm BOOL | fForce |
|
|
*
|
|
* Nonzero if we should detach even if we are not the top-level
|
|
* subclass.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
DetachSubclassHeader(HWND hwnd, PSUBCLASS_HEADER pHeader, BOOL fForce)
|
|
{
|
|
WNDPROC wndprocOld;
|
|
|
|
AssertF(InCrit()); /* we party on the subclass call chain here */
|
|
AssertF(pHeader); /* fear */
|
|
|
|
/*
|
|
* If we are not being forced to remove and the window is still
|
|
* valid then sniff around a little and decide if it's a good
|
|
* idea to detach now.
|
|
*/
|
|
if (!fForce && hwnd) {
|
|
AssertF(pHeader == FastGetSubclassHeader(hwnd)); /* paranoia */
|
|
|
|
/* should always have the "call original" node */
|
|
AssertF(pHeader->uRefs);
|
|
|
|
/*
|
|
* We can't have active clients.
|
|
* We can't have people still on our stack.
|
|
*/
|
|
if (pHeader->uRefs <= 1 && !pHeader->pFrameCur) {
|
|
|
|
/*
|
|
* We must be in the correct context.
|
|
*/
|
|
if (pHeader->dwThreadId == GetCurrentThreadId()) {
|
|
|
|
/*
|
|
* We kept the original window procedure as refdata for our
|
|
* CallOriginalWndProc subclass callback.
|
|
*/
|
|
wndprocOld = (WNDPROC)pHeader->CallArray[0].dwRefData;
|
|
AssertF(wndprocOld);
|
|
|
|
/*
|
|
* Make sure we are the top of the subclass chain.
|
|
*/
|
|
if (GetWindowProc(hwnd) == MasterSubclassProc) {
|
|
|
|
/*
|
|
* go ahead and try to detach
|
|
*/
|
|
#ifdef WINNT
|
|
if (SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR)wndprocOld)) {
|
|
#else
|
|
if (SubclassWindow(hwnd, wndprocOld)) {
|
|
#endif
|
|
SquirtSqflPtszV(sqfl, TEXT("DetachSubclassHeader: ")
|
|
TEXT("Unhooked"));
|
|
} else {
|
|
AssertF(0); /* just plain shouldn't happen */
|
|
goto failed;
|
|
}
|
|
} else { /* Not at top of chain; can't do it */
|
|
SquirtSqflPtszV(sqfl, TEXT("DetachSubclassHeader: ")
|
|
TEXT("Somebody else subclassed"));
|
|
goto failed;
|
|
}
|
|
} else { /* Out of context. Try again later. */
|
|
SendNotifyMessage(hwnd, WM_NULL, 0, 0L);
|
|
goto failed;
|
|
}
|
|
} else {
|
|
// 7/18/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl, TEXT("DetachSubclassHeader: ")
|
|
TEXT("Still %d users, %p frame"),
|
|
pHeader->uRefs, pHeader->pFrameCur);
|
|
goto failed;
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
#ifdef DEBUG
|
|
{
|
|
/*
|
|
* warn about anybody who hasn't unhooked yet
|
|
*/
|
|
UINT uCur;
|
|
SUBCLASS_CALL *pCall;
|
|
|
|
uCur = pHeader->uRefs;
|
|
pCall = pHeader->CallArray + uCur;
|
|
/* don't complain about our 'call original' node */
|
|
while (--uCur) {
|
|
pCall--;
|
|
if (pCall->pfnSubclass) {
|
|
/*
|
|
* always warn about these they could be leaks
|
|
*/
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl | sqflError, TEXT("warning: orphan subclass: ")
|
|
TEXT("fn %p, id %08x, dw %08x"),
|
|
pCall->pfnSubclass, pCall->uIdSubclass,
|
|
pCall->dwRefData);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
/*
|
|
* free the header now
|
|
*/
|
|
FreeSubclassHeader(hwnd, pHeader);
|
|
|
|
DllFreeLibrary(); /* Undo LoadLibrary when we hooked */
|
|
|
|
|
|
failed:;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | PurgeSingleCallNode |
|
|
*
|
|
* Purges a single dead node in the call array.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* The header associated with the window.
|
|
* The <p uCleanup> field is the index of the node being
|
|
* cleaned up.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
PurgeSingleCallNode(HWND hwnd, PSUBCLASS_HEADER pHeader)
|
|
{
|
|
|
|
AssertF(InCrit()); /* we will try to re-arrange the call array */
|
|
|
|
if (pHeader->uCleanup) {/* Sanity check */
|
|
UINT uRemain;
|
|
|
|
SquirtSqflPtszV(sqfl,
|
|
TEXT("PurgeSingleCallNode: Purging number %d"),
|
|
pHeader->uCleanup);
|
|
|
|
/*
|
|
* and a little paranoia
|
|
*/
|
|
AssertF(pHeader->CallArray[pHeader->uCleanup].pfnSubclass == 0);
|
|
|
|
AssertF(fLimpFF(pHeader->pFrameCur,
|
|
pHeader->uCleanup < pHeader->pFrameCur->uDeepestCall));
|
|
|
|
/*
|
|
* are there any call nodes above the one we're about to remove?
|
|
*/
|
|
uRemain = pHeader->uRefs - pHeader->uCleanup;
|
|
if (uRemain > 0) {
|
|
/*
|
|
* yup, need to fix up the array the hard way
|
|
*/
|
|
SUBCLASS_CALL *pCall;
|
|
SUBCLASS_FRAME *pFrame;
|
|
UINT uCur, uMax;
|
|
|
|
/*
|
|
* move the remaining nodes down into the empty space
|
|
*/
|
|
pCall = pHeader->CallArray + pHeader->uCleanup;
|
|
/*
|
|
* Since the souce and destination overlap (unless there's only
|
|
* one node remaining) the behavior of memcpy is undefined.
|
|
* memmove (aka MoveMemory) would guarantee the correct
|
|
* behavior but requires the runtime library.
|
|
* Since this is the only function we require in retail from the
|
|
* RTL, it is not worth the 22% bloat we gain from using the
|
|
* static version and using the dynamic version is a load time
|
|
* and redist test hit. So copy the array one element at a time.
|
|
*/
|
|
for( uCur = 0; uCur < uRemain; uCur++ )
|
|
{
|
|
memcpy( &pCall[uCur], &pCall[uCur+1], sizeof(*pCall) );
|
|
}
|
|
|
|
/*
|
|
* update the call indices of any active frames
|
|
*/
|
|
uCur = pHeader->uCleanup;
|
|
pFrame = pHeader->pFrameCur;
|
|
while (pFrame) {
|
|
if (pFrame->uCallIndex >= uCur) {
|
|
pFrame->uCallIndex--;
|
|
|
|
if (pFrame->uDeepestCall >= uCur) {
|
|
pFrame->uDeepestCall--;
|
|
}
|
|
}
|
|
|
|
pFrame = pFrame->pFramePrev;
|
|
}
|
|
|
|
/*
|
|
* now search for any other dead call nodes in the remaining area
|
|
*/
|
|
uMax = pHeader->uRefs - 1; /* we haven't decremented uRefs yet */
|
|
while (uCur < uMax && pCall->pfnSubclass) {
|
|
pCall++;
|
|
uCur++;
|
|
}
|
|
pHeader->uCleanup = (uCur < uMax) ? uCur : 0;
|
|
} else {
|
|
/*
|
|
* No call nodes above. This case is easy.
|
|
*/
|
|
pHeader->uCleanup = 0;
|
|
}
|
|
|
|
/*
|
|
* finally, decrement the client count
|
|
*/
|
|
pHeader->uRefs--;
|
|
SquirtSqflPtszV(sqfl, TEXT("warning: PurgeSingleCallNode: ")
|
|
TEXT("Still %d refs"), pHeader->uRefs);
|
|
|
|
} else {
|
|
AssertF(0); /* Nothing to do! */
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | CompactSubclassHeader |
|
|
*
|
|
* Attempts to compact the subclass array, freeing the
|
|
* subclass header if the array is empty.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* The header associated with the window.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
CompactSubclassHeader(HWND hwnd, PSUBCLASS_HEADER pHeader)
|
|
{
|
|
AssertF(InCrit()); /* we will try to re-arrange the call array */
|
|
|
|
/*
|
|
* we must handle the "window destroyed unexpectedly during callback" case
|
|
*/
|
|
if (hwnd) {
|
|
/*
|
|
* Clean out as many dead callbacks as possible.
|
|
*
|
|
* The "DeepestCall" test is an optimization so we don't go
|
|
* purging call nodes when no active frame cares.
|
|
*
|
|
* (I'm not entirely conviced of this. I mean, we have to
|
|
* purge it eventually anyway, right?)
|
|
*/
|
|
while (pHeader->uCleanup &&
|
|
fLimpFF(pHeader->pFrameCur,
|
|
pHeader->uCleanup < pHeader->pFrameCur->uDeepestCall)) {
|
|
PurgeSingleCallNode(hwnd, pHeader);
|
|
}
|
|
|
|
/*
|
|
* do we still have clients?
|
|
*/
|
|
if (pHeader->uRefs > 1) {
|
|
SquirtSqflPtszV(sqfl, TEXT("CompactSubclassHeader: ")
|
|
TEXT("Still %d users"), pHeader->uRefs);
|
|
/*
|
|
* yes, shrink our allocation, leaving room for at least one client
|
|
*/
|
|
ReAllocSubclassHeader(hwnd, pHeader, pHeader->uRefs + 1);
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* There are no clients left, or the window is gone.
|
|
* Try to detach and free
|
|
*/
|
|
DetachSubclassHeader(hwnd, pHeader, FALSE);
|
|
|
|
done:;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func PSUBCLASS_CALL | FindCallRecord |
|
|
*
|
|
* Searches for a call record with the specified subclass proc
|
|
* and id, and returns its address. If no such call record is
|
|
* found then NULL is returned.
|
|
*
|
|
* This is a helper function used when we need to track down
|
|
* a callback because the client is changing its refdata or
|
|
* removing it.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* The header in which to search.
|
|
*
|
|
* @parm SUBCLASSPROC | pfnSubclass |
|
|
*
|
|
* Subclass callback procedure to locate.
|
|
*
|
|
* @parm UINT | uIdSubclass |
|
|
*
|
|
* Instance identifier associated with the callback.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
SUBCLASS_CALL * INTERNAL
|
|
FindCallRecord(PSUBCLASS_HEADER pHeader, SUBCLASSPROC pfnSubclass,
|
|
UINT_PTR uIdSubclass)
|
|
{
|
|
SUBCLASS_CALL *pCall;
|
|
UINT uCallIndex;
|
|
|
|
AssertF(InCrit()); /* we'll be scanning the call array */
|
|
|
|
/*
|
|
* scan the call array. note that we assume there is always at least
|
|
* one member in the table (our CallOriginalWndProc record)
|
|
*/
|
|
uCallIndex = pHeader->uRefs;
|
|
pCall = &pHeader->CallArray[uCallIndex];
|
|
do {
|
|
uCallIndex--;
|
|
pCall--;
|
|
if ((pCall->pfnSubclass == pfnSubclass) &&
|
|
(pCall->uIdSubclass == uIdSubclass))
|
|
{
|
|
return pCall;
|
|
}
|
|
} while (uCallIndex != (UINT)-1);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL | GetWindowSubclass |
|
|
*
|
|
* Retrieves the reference data for the specified window
|
|
* subclass callback.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm SUBCLASSPROC | pfnSubclass |
|
|
*
|
|
* Subclass callback procedure to locate.
|
|
*
|
|
* @parm UINT | uIdSubclass |
|
|
*
|
|
* Instance identifier associated with the callback.
|
|
*
|
|
* @parm LPDWORD | pdwRefData |
|
|
*
|
|
* Output pointer.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL EXTERNAL
|
|
GetWindowSubclass(HWND hwnd, SUBCLASSPROC pfnSubclass, UINT_PTR uIdSubclass,
|
|
PULONG_PTR pdwRefData)
|
|
{
|
|
BOOL fRc;
|
|
ULONG_PTR dwRefData;
|
|
|
|
DllEnterCrit();
|
|
|
|
/*
|
|
* sanity
|
|
*/
|
|
if (IsWindow(hwnd) && pfnSubclass) {
|
|
PSUBCLASS_HEADER pHeader;
|
|
SUBCLASS_CALL *pCall;
|
|
|
|
/*
|
|
* if we've subclassed it and they are a client then get the refdata
|
|
*/
|
|
pHeader = GetSubclassHeader(hwnd);
|
|
if (pHeader &&
|
|
(pHeader != (PSUBCLASS_HEADER)1) &&
|
|
(pCall = FindCallRecord(pHeader, pfnSubclass, uIdSubclass)) != 0) {
|
|
/*
|
|
* fetch the refdata and note success
|
|
*/
|
|
fRc = 1;
|
|
dwRefData = pCall->dwRefData;
|
|
} else {
|
|
fRc = 0;
|
|
dwRefData = 0;
|
|
}
|
|
|
|
} else { /* Invalid window handle */
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl | sqflError, TEXT("GetWindowSubclass: ")
|
|
TEXT("Bad window %p or callback %p"),
|
|
hwnd, pfnSubclass);
|
|
fRc = 0;
|
|
dwRefData = 0;
|
|
}
|
|
|
|
/*
|
|
* we always fill in/zero pdwRefData regradless of result
|
|
*/
|
|
if (pdwRefData) {
|
|
*pdwRefData = dwRefData;
|
|
}
|
|
|
|
DllLeaveCrit();
|
|
|
|
return fRc;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL | SetWindowSubclass |
|
|
*
|
|
* Installs/updates a window subclass callback. Subclass
|
|
* callbacks are identified by their callback address and id pair.
|
|
* If the specified callback/id pair is not yet installed then
|
|
* the procedure installs the pair. If the callback/id pair is
|
|
* already installed, then this procedure changes the reference
|
|
* data for the pair.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm SUBCLASSPROC | pfnSubclass |
|
|
*
|
|
* Subclass callback procedure to install or modify.
|
|
*
|
|
* @parm UINT | uIdSubclass |
|
|
*
|
|
* Instance identifier associated with the callback.
|
|
*
|
|
* @parm DWORD | dwRefData |
|
|
*
|
|
* Reference data to associate with the callback/id.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL EXTERNAL
|
|
SetWindowSubclass(HWND hwnd, SUBCLASSPROC pfnSubclass, UINT_PTR uIdSubclass,
|
|
ULONG_PTR dwRefData)
|
|
{
|
|
BOOL fRc;
|
|
|
|
/*
|
|
* sanity
|
|
*/
|
|
if (IsWindow(hwnd) && pfnSubclass) {
|
|
SUBCLASS_HEADER *pHeader;
|
|
|
|
/*
|
|
* we party on the subclass call chain here
|
|
*/
|
|
DllEnterCrit();
|
|
|
|
/*
|
|
* actually subclass the window
|
|
*/
|
|
/*
|
|
* Prefix gets confused (mb:34501) by this. I assume this is because
|
|
* AttachSubclassHeader returns a pointer to allocated memory but we
|
|
* allow the pointer to go out of context without saving it. This is
|
|
* OK because AttachSubclassHeader already saved it for us.
|
|
*/
|
|
pHeader = AttachSubclassHeader(hwnd);
|
|
if (pHeader) {
|
|
SUBCLASS_CALL *pCall;
|
|
|
|
/*
|
|
* find a call node for this caller
|
|
*/
|
|
pCall = FindCallRecord(pHeader, pfnSubclass, uIdSubclass);
|
|
if (pCall == NULL) {
|
|
/*
|
|
* not found, alloc a new one
|
|
*/
|
|
SUBCLASS_HEADER *pHeaderT =
|
|
ReAllocSubclassHeader(hwnd, pHeader, pHeader->uRefs + 1);
|
|
|
|
if (pHeaderT) {
|
|
pHeader = pHeaderT;
|
|
pCall = &pHeader->CallArray[pHeader->uRefs++];
|
|
} else {
|
|
/*
|
|
* re-query in case it is already gone
|
|
*/
|
|
pHeader = FastGetSubclassHeader(hwnd);
|
|
if (pHeader) {
|
|
CompactSubclassHeader(hwnd, pHeader);
|
|
}
|
|
goto bail;
|
|
}
|
|
|
|
}
|
|
|
|
/*
|
|
* fill in the subclass call data
|
|
*/
|
|
pCall->pfnSubclass = pfnSubclass;
|
|
pCall->uIdSubclass = uIdSubclass;
|
|
pCall->dwRefData = dwRefData;
|
|
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl,
|
|
TEXT("SetWindowSubclass: Added %p/%d as %d"),
|
|
pfnSubclass, uIdSubclass, pHeader->uRefs - 1);
|
|
|
|
fRc = 1;
|
|
|
|
} else { /* Unable to subclass */
|
|
bail:;
|
|
fRc = 0;
|
|
}
|
|
DllLeaveCrit();
|
|
} else {
|
|
fRc = 0; /* Invalid parameter */
|
|
}
|
|
|
|
return fRc;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func BOOL | RemoveWindowSubclass |
|
|
*
|
|
* Removes a subclass callback from a window.
|
|
* Subclass callbacks are identified by their
|
|
* callback address and id pair.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm SUBCLASSPROC | pfnSubclass |
|
|
*
|
|
* Subclass callback procedure to remove.
|
|
*
|
|
* @parm UINT | uIdSubclass |
|
|
*
|
|
* Instance identifier associated with the callback.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
BOOL EXTERNAL
|
|
RemoveWindowSubclass(HWND hwnd, SUBCLASSPROC pfnSubclass, UINT_PTR uIdSubclass)
|
|
{
|
|
BOOL fRc;
|
|
|
|
/*
|
|
* sanity
|
|
*/
|
|
if (IsWindow(hwnd) && pfnSubclass) {
|
|
SUBCLASS_HEADER *pHeader;
|
|
|
|
/*
|
|
* we party on the subclass call chain here
|
|
*/
|
|
DllEnterCrit();
|
|
|
|
/*
|
|
* obtain our subclass data and find the callback to remove.
|
|
*/
|
|
pHeader = GetSubclassHeader(hwnd);
|
|
if (pHeader && (pHeader != (PSUBCLASS_HEADER)1) ) {
|
|
SUBCLASS_CALL *pCall;
|
|
|
|
/*
|
|
* find the callback to remove
|
|
*/
|
|
pCall = FindCallRecord(pHeader, pfnSubclass, uIdSubclass);
|
|
|
|
if (pCall) {
|
|
UINT uCall;
|
|
|
|
/*
|
|
* disable this node.
|
|
*/
|
|
pCall->pfnSubclass = 0;
|
|
|
|
/*
|
|
* Remember that we have something to clean up.
|
|
*
|
|
* Set uCleanup to the index of the shallowest node that
|
|
* needs to be cleaned up. CompactSubclassHeader will
|
|
* clean up everything from uCleanup onward.
|
|
*/
|
|
|
|
uCall = (UINT)(pCall - pHeader->CallArray);
|
|
if (fLimpFF(pHeader->uCleanup, uCall < pHeader->uCleanup)) {
|
|
pHeader->uCleanup = uCall;
|
|
}
|
|
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl,
|
|
TEXT("RemoveWindowSubclass: Removing %p/%d as %d"),
|
|
pfnSubclass, uIdSubclass, uCall);
|
|
|
|
/*
|
|
* now try to clean up any unused nodes
|
|
*/
|
|
CompactSubclassHeader(hwnd, pHeader);
|
|
|
|
/*
|
|
* the call above can realloc or free the subclass
|
|
* header for this window, so make sure we don't use it.
|
|
*/
|
|
D(pHeader = 0);
|
|
|
|
fRc = 1;
|
|
|
|
} else { /* Not found */
|
|
fRc = 0;
|
|
}
|
|
} else { /* Never subclassed (ergo not found) */
|
|
fRc = 0;
|
|
}
|
|
|
|
/*
|
|
* release the critical section and return the result
|
|
*/
|
|
DllLeaveCrit();
|
|
} else {
|
|
fRc = 0; /* Validation failed */
|
|
}
|
|
return fRc;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LRESULT | DefSubclassProc |
|
|
*
|
|
* Calls the next handler in the window's subclass chain.
|
|
* The last handler in the subclass chain is installed by us,
|
|
* and calls the original window procedure for the window.
|
|
*
|
|
* Every subclass procedure should call <f DefSubclassProc>
|
|
* in order to allow the message to be processed by other handlers.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window in question.
|
|
*
|
|
* @parm UINT | wm |
|
|
*
|
|
* Window message that needs to go to the original <t WNDPROC>.
|
|
*
|
|
* @parm WPARAM | wp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
* @parm LPARAM | lp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
LRESULT EXTERNAL
|
|
DefSubclassProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp)
|
|
{
|
|
LRESULT lResult;
|
|
|
|
/*
|
|
* make sure the window is still valid
|
|
*/
|
|
if (IsWindow(hwnd)) {
|
|
PSUBCLASS_HEADER pHeader;
|
|
|
|
/*
|
|
* take the critical section while we figure out who to call next
|
|
*/
|
|
AssertF(!InCrit());
|
|
DllEnterCrit();
|
|
|
|
/*
|
|
* complain if we are being called improperly
|
|
*/
|
|
pHeader = FastGetSubclassHeader(hwnd);
|
|
if (pHeader &&
|
|
pHeader->pFrameCur &&
|
|
GetCurrentThreadId() == pHeader->dwThreadId) {
|
|
|
|
/*
|
|
* call the next proc in the subclass chain
|
|
*
|
|
* WARNING: this call temporarily releases the critical section
|
|
* WARNING: pHeader is invalid when this call returns
|
|
*/
|
|
lResult = CallNextSubclassProc(pHeader, hwnd, wm, wp, lp);
|
|
D(pHeader = 0);
|
|
|
|
} else {
|
|
SquirtSqflPtszV(sqfl | sqflError,
|
|
TEXT("DefSubclassProc: Called improperly"));
|
|
lResult = 0;
|
|
}
|
|
DllLeaveCrit();
|
|
|
|
} else {
|
|
// 7/19/2000(a-JiTay): IA64: Use %p format specifier for 32/64-bit pointers.
|
|
SquirtSqflPtszV(sqfl | sqflError,
|
|
TEXT("DefSubclassProc: %P not a window"),
|
|
hwnd);
|
|
lResult = 0;
|
|
}
|
|
|
|
return lResult;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | UpdateDeepestCall |
|
|
*
|
|
* Updates the deepest call index for the specified frame.
|
|
*
|
|
* @parm PSUBCLASS_FRAME | pFrame |
|
|
*
|
|
* Frame in question.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
UpdateDeepestCall(SUBCLASS_FRAME *pFrame)
|
|
{
|
|
AssertF(InCrit()); /* we are partying on the frame list */
|
|
|
|
/*
|
|
* My deepest call equals my current call or my parent's
|
|
* deepest call, whichever is deeper.
|
|
*/
|
|
if (pFrame->pFramePrev &&
|
|
(pFrame->pFramePrev->uDeepestCall < pFrame->uCallIndex)) {
|
|
pFrame->uDeepestCall = pFrame->pFramePrev->uDeepestCall;
|
|
} else {
|
|
pFrame->uDeepestCall = pFrame->uCallIndex;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | EnterSubclassFrame |
|
|
*
|
|
* Sets up a new subclass frame for the specified header,
|
|
* saving away the previous one.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* Header in question.
|
|
*
|
|
* @parm PSUBCLASS_FRAME | pFrame |
|
|
*
|
|
* Brand new frame to link in.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INLINE
|
|
EnterSubclassFrame(PSUBCLASS_HEADER pHeader, SUBCLASS_FRAME *pFrame)
|
|
{
|
|
AssertF(InCrit()); /* we are partying on the header and frame list */
|
|
|
|
/*
|
|
* fill in the frame and link it into the header
|
|
*/
|
|
pFrame->uCallIndex = pHeader->uRefs + 1;
|
|
pFrame->pFramePrev = pHeader->pFrameCur;
|
|
pFrame->pHeader = pHeader;
|
|
pHeader->pFrameCur = pFrame;
|
|
|
|
/*
|
|
* initialize the deepest call index for this frame
|
|
*/
|
|
UpdateDeepestCall(pFrame);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | LeaveSubclassFrame |
|
|
*
|
|
* Tear down the current subclass frame, restoring the previous one.
|
|
*
|
|
* @parm PSUBCLASS_FRAME | pFrame |
|
|
*
|
|
* Frame going away.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
PSUBCLASS_HEADER INLINE
|
|
LeaveSubclassFrame(SUBCLASS_FRAME *pFrame)
|
|
{
|
|
PSUBCLASS_HEADER pHeader;
|
|
|
|
AssertF(InCrit()); /* we are partying on the header */
|
|
|
|
/*
|
|
* unlink the frame from its header (if it still exists)
|
|
*/
|
|
pHeader = pFrame->pHeader;
|
|
if (pHeader) {
|
|
pHeader->pFrameCur = pFrame->pFramePrev;
|
|
}
|
|
|
|
return pHeader;
|
|
}
|
|
|
|
#ifdef SUBCLASS_HANDLEEXCEPTIONS
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | SubclassFrameException |
|
|
*
|
|
* Clean up when a exception is thrown from a subclass frame.
|
|
*
|
|
* @parm PSUBCLASS_FRAME | pFrame |
|
|
*
|
|
* Frame to clean up.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
SubclassFrameException(SUBCLASS_FRAME *pFrame)
|
|
{
|
|
/*
|
|
* clean up the current subclass frame
|
|
*/
|
|
AssertF(!InCrit());
|
|
DllEnterCrit();
|
|
|
|
SquirtSqflPtszV(sqfl | sqflError, TEXT("SubclassFrameException: ")
|
|
TEXT("cleaning up subclass frame after exception"));
|
|
LeaveSubclassFrame(pFrame);
|
|
DllLeaveCrit();
|
|
}
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LRESULT | MasterSubclassProc |
|
|
*
|
|
* The window procedure we install to dispatch subclass
|
|
* callbacks.
|
|
*
|
|
* It maintains a linked list of "frames" through the stack
|
|
* which allow <f DefSubclassProc> to call the right subclass
|
|
* procedure in multiple-message scenarios.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window under attack.
|
|
*
|
|
* @parm UINT | wm |
|
|
*
|
|
* Window message.
|
|
*
|
|
* @parm WPARAM | wp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
* @parm LPARAM | lp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
LRESULT CALLBACK
|
|
MasterSubclassProc(HWND hwnd, UINT wm, WPARAM wp, LPARAM lp)
|
|
{
|
|
SUBCLASS_HEADER *pHeader;
|
|
LRESULT lResult;
|
|
|
|
/*
|
|
* prevent people from partying on the callback chain while we look at it
|
|
*/
|
|
AssertF(!InCrit());
|
|
DllEnterCrit();
|
|
|
|
/*
|
|
* We'd better have our data.
|
|
*/
|
|
pHeader = FastGetSubclassHeader(hwnd);
|
|
if (pHeader) {
|
|
SUBCLASS_FRAME Frame;
|
|
|
|
/*
|
|
* set up a new subclass frame and save away the previous one
|
|
*/
|
|
EnterSubclassFrame(pHeader, &Frame);
|
|
|
|
#ifdef SUBCLASS_HANDLEEXCEPTIONS
|
|
__try /* protect our state information from exceptions */
|
|
#endif
|
|
{
|
|
/*
|
|
* go ahead and call the subclass chain on this frame
|
|
*
|
|
* WARNING: this call temporarily releases the critical section
|
|
* WARNING: pHeader is invalid when this call returns
|
|
*/
|
|
lResult =
|
|
CallNextSubclassProc(pHeader, hwnd, wm, wp, lp);
|
|
D(pHeader = 0);
|
|
}
|
|
#ifdef SUBCLASS_HANDLEEXCEPTIONS
|
|
__except (SubclassFrameException(&Frame), EXCEPTION_CONTINUE_SEARCH)
|
|
{
|
|
AssertF(0);
|
|
}
|
|
#endif
|
|
|
|
AssertF(InCrit());
|
|
|
|
/*
|
|
* restore the previous subclass frame
|
|
*/
|
|
pHeader = LeaveSubclassFrame(&Frame);
|
|
|
|
/*
|
|
* Do postprocessing if the header is still here.
|
|
*/
|
|
if (pHeader) {
|
|
|
|
/*
|
|
* was the window nuked (somehow)
|
|
* without us seeing the WM_NCDESTROY?
|
|
*/
|
|
if (!IsWindow(hwnd)) {
|
|
/*
|
|
* EVIL! somebody subclassed after us and didn't pass on WM_NCDESTROY
|
|
*/
|
|
AssertF(!TEXT("unknown subclass proc swallowed a WM_NCDESTROY"));
|
|
|
|
/* go ahead and clean up now */
|
|
hwnd = 0;
|
|
wm = WM_NCDESTROY;
|
|
}
|
|
|
|
/*
|
|
* if we are returning from a WM_NCDESTROY then we need to clean up
|
|
*/
|
|
if (wm == WM_NCDESTROY) {
|
|
DetachSubclassHeader(hwnd, pHeader, TRUE);
|
|
} else {
|
|
|
|
/*
|
|
* is there any pending cleanup, or are all our clients gone?
|
|
*/
|
|
if (pHeader->uCleanup ||
|
|
(!pHeader->pFrameCur && (pHeader->uRefs <= 1))) {
|
|
CompactSubclassHeader(hwnd, pHeader);
|
|
D(pHeader = 0);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* all done
|
|
*/
|
|
|
|
} else {
|
|
/*
|
|
* Header is gone. We already cleaned up in a nested frame.
|
|
*/
|
|
}
|
|
DllLeaveCrit();
|
|
AssertF(!InCrit());
|
|
|
|
} else { /* Our property vanished! */
|
|
DllLeaveCrit();
|
|
lResult = SubclassDeath(hwnd, wm, wp, lp);
|
|
}
|
|
|
|
return lResult;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func UINT | EnterSubclassCallback |
|
|
*
|
|
* Finds the next callback in the subclass chain and updates
|
|
* <p pFrame> to indicate that we are calling it.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* Controlling header.
|
|
*
|
|
* @parm PSUBCLASS_FRAME | pFrame |
|
|
*
|
|
* Frame to update.
|
|
*
|
|
* @parm SUBCLASS_CALL * | pCallChosen |
|
|
*
|
|
* The call selected for calling.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
UINT INTERNAL
|
|
EnterSubclassCallback(PSUBCLASS_HEADER pHeader, SUBCLASS_FRAME *pFrame,
|
|
SUBCLASS_CALL *pCallChosen)
|
|
{
|
|
SUBCLASS_CALL *pCall;
|
|
UINT uDepth;
|
|
|
|
/*
|
|
* we will be scanning the subclass chain and updating frame data
|
|
*/
|
|
AssertF(InCrit());
|
|
|
|
/*
|
|
* scan the subclass chain for the next callable subclass callback
|
|
* Assert that the loop will terminate.
|
|
*/
|
|
AssertF(pHeader->CallArray[0].pfnSubclass);
|
|
pCall = pHeader->CallArray + pFrame->uCallIndex;
|
|
uDepth = 0;
|
|
do {
|
|
uDepth++;
|
|
pCall--;
|
|
|
|
} while (!pCall->pfnSubclass);
|
|
|
|
/*
|
|
* copy the callback information for the caller
|
|
*/
|
|
pCallChosen->pfnSubclass = pCall->pfnSubclass;
|
|
pCallChosen->uIdSubclass = pCall->uIdSubclass;
|
|
pCallChosen->dwRefData = pCall->dwRefData;
|
|
|
|
/*
|
|
* adjust the frame's call index by the depth we entered
|
|
*/
|
|
pFrame->uCallIndex -= uDepth;
|
|
|
|
/*
|
|
* keep the deepest call index up to date
|
|
*/
|
|
UpdateDeepestCall(pFrame);
|
|
|
|
return uDepth;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | LeaveSubclassCallback |
|
|
*
|
|
* Get out one level.
|
|
*
|
|
* @parm PSUBCLASS_FRAME | pFrame |
|
|
*
|
|
* Frame to update.
|
|
*
|
|
* @parm UINT | uDepth |
|
|
*
|
|
* Who just finished.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INLINE
|
|
LeaveSubclassCallback(SUBCLASS_FRAME *pFrame, UINT uDepth)
|
|
{
|
|
/*
|
|
* we will be updating subclass frame data
|
|
*/
|
|
AssertF(InCrit());
|
|
|
|
/*
|
|
* adjust the frame's call index by the depth we entered and return
|
|
*/
|
|
pFrame->uCallIndex += uDepth;
|
|
|
|
/*
|
|
* keep the deepest call index up to date
|
|
*/
|
|
UpdateDeepestCall(pFrame);
|
|
}
|
|
|
|
#ifdef SUBCLASS_HANDLEEXCEPTIONS
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func void | SubclassCallbackException |
|
|
*
|
|
* Clean up when a subclass callback throws an exception.
|
|
*
|
|
* @parm PSUBCLASS_FRAME | pFrame |
|
|
*
|
|
* Frame to clean up.
|
|
*
|
|
* @parm UINT | uDepth |
|
|
*
|
|
* Where we were.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
void INTERNAL
|
|
SubclassCallbackException(SUBCLASS_FRAME *pFrame, UINT uDepth)
|
|
{
|
|
/*
|
|
* clean up the current subclass callback
|
|
*/
|
|
AssertF(!InCrit());
|
|
DllEnterCrit();
|
|
SquirtSqflPtszV(sqfl | sqflError, TEXT("SubclassCallbackException: ")
|
|
TEXT("cleaning up subclass callback after exception"));
|
|
LeaveSubclassCallback(pFrame, uDepth);
|
|
DllLeaveCrit();
|
|
}
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* @doc INTERNAL
|
|
*
|
|
* @func LRESULT | CallNextSubclassProc |
|
|
*
|
|
* Calls the next subclass callback in the subclass chain.
|
|
*
|
|
* WARNING: this call temporarily releases the critical section.
|
|
*
|
|
* WARNING: <p pHeader> is invalid when this call returns.
|
|
*
|
|
* @parm PSUBCLASS_HEADER | pHeader |
|
|
*
|
|
* The header that is tracking the state.
|
|
*
|
|
* @parm HWND | hwnd |
|
|
*
|
|
* Window under attack.
|
|
*
|
|
* @parm UINT | wm |
|
|
*
|
|
* Window message.
|
|
*
|
|
* @parm WPARAM | wp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
* @parm LPARAM | lp |
|
|
*
|
|
* Meaning depends on window message.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
LRESULT INTERNAL
|
|
CallNextSubclassProc(PSUBCLASS_HEADER pHeader, HWND hwnd, UINT wm,
|
|
WPARAM wp, LPARAM lp)
|
|
{
|
|
SUBCLASS_CALL Call;
|
|
SUBCLASS_FRAME *pFrame;
|
|
LRESULT lResult;
|
|
UINT uDepth;
|
|
|
|
AssertF(InCrit()); /* sanity */
|
|
AssertF(pHeader); /* paranoia */
|
|
|
|
/*
|
|
* get the current subclass frame
|
|
*/
|
|
pFrame = pHeader->pFrameCur;
|
|
AssertF(pFrame);
|
|
|
|
/*
|
|
* get the next subclass call we need to make
|
|
*/
|
|
uDepth = EnterSubclassCallback(pHeader, pFrame, &Call);
|
|
|
|
/*
|
|
* leave the critical section so we don't deadlock in our callback
|
|
*
|
|
* WARNING: pHeader is invalid when this call returns
|
|
*/
|
|
DllLeaveCrit();
|
|
D(pHeader = 0);
|
|
|
|
/*
|
|
* we call the outside world so prepare to deadlock if we have the critsec
|
|
*/
|
|
AssertF(!InCrit());
|
|
|
|
#ifdef SUBCLASS_HANDLEEXCEPTIONS
|
|
__try /* protect our state information from exceptions */
|
|
#endif
|
|
{
|
|
/*
|
|
* call the chosen subclass proc
|
|
*/
|
|
AssertF(Call.pfnSubclass);
|
|
|
|
lResult = Call.pfnSubclass(hwnd, wm, wp, lp,
|
|
Call.uIdSubclass, Call.dwRefData);
|
|
}
|
|
#ifdef SUBCLASS_HANDLEEXCEPTIONS
|
|
__except (SubclassCallbackException(pFrame, uDepth),
|
|
EXCEPTION_CONTINUE_SEARCH)
|
|
{
|
|
AssertF(0);
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* we left the critical section before calling out so re-enter it
|
|
*/
|
|
AssertF(!InCrit());
|
|
DllEnterCrit();
|
|
|
|
/*
|
|
* finally, clean up and return
|
|
*/
|
|
LeaveSubclassCallback(pFrame, uDepth);
|
|
return lResult;
|
|
}
|
|
|