able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/unicows/godot/subclass.c

831 lines
30 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 2000-2001, Microsoft Corporation All rights reserved.
Module Name:
subclass.c
Abstract:
This file contains functions that support our subclassing efforts. Here is how it works:
Each window we create must be subclassed so we can maintain the illusion of Unicodality
on it. We therefore store a pointer to some memory that contains all of the information
we need to properly call the wndproc, stored in a GODOTWND structure. Since the caller
can actually subclass the window, we need to store a linked list of these structures.
NOTE: From comctl32.dll's SUBCLASS.C:
Win95's property code is BROKEN. If you SetProp using a text string, USER
// adds and removes atoms for the property symmetrically, including when the
// window is destroyed with properties lying around (good). Unfortunately, if
// you SetProp using a global atom, USER doesn't do things quite right in the
// window cleanup case. It uses the atom without adding references in SetProp
// calls and without deleting them in RemoveProp calls (good so far). However,
// when a window with one of these properties lying around is cleaned up, USER
// will delete the atom on you. This tends to break apps that do the
// following:
//
// - MyAtom = GlobalAddAtom("foo"); // at app startup
// - SetProp(SomeWindow, MyAtom, MyData);
// - <window gets destroyed, USER deletes atom>
// - <time passes>
// - SetProp(SomeOtherWindow, MyAtom, MyData); // fails or uses random atom
// - GlobalDeleteAtom(MyAtom); // fails or deletes random atom
In order to avoid this bug in the Win9x property code, we do not store this as an atom,
instead choosing to use an actual string and letting the system do all the work to manage
the propname. We also wrap all of the property functions, both A and W, to fail the
creation, altering, or removal of our one property. This does not solve the problem
completely since they can always work outside Godot and wreak havoc, but we cannot solve
THAT without replacing USER32.DLL on the machine! We still do a call to GlobalAddAtom and
just do a lot of aggressive calls to refcount it this way. Slightly slower perf-wise but
better guarantees!
In order to make sure that the user does not directly have their wndproc called by the
OS (which is not Unicode!), we do not ever directly give them the true wndproc, but
instead we give them a special pointer. Per RaymondC, addresses with 64k of the 2gb
boundary (0x7FFF0000 - 0x7FFFFFFF) are always invalid proc addresses, and we need these IDs
to be invalid so that someone not going through CallWindowProc will fault right away rather
then calling into random memory. The first pointer for each window is always going to be
0x7FFFFFFF - 1, and each additional subclass a user adds via SetWindowLong will subtract
another number (calculated via CWnd). Since the user never could have more than 64,000
subclasses, this should give us plenty of room. Any time we get a call to our CallWindowProc
wrapper, we route these "GodotID" values appropriately.
Note that we also store DLGPROCs via the same means. No particular GODOTWND will ever have
both a DLGPROC and a WNDPROC in it, but they will always have unique IDs for each one so
we need separate GODOTWNDs here. Which one it is can be determined by the fWndproc member.
When they add a sublass (via SetWindowLong), we add the items to the linked list using a
"PUSH" type operation. The most recent subclass is always on top, and the base subclass
is always on the bottom.
If they unsubclass (call SetWindowLong, passing in one of our own GodotID values) in the
right order as they are supposed to, we simply use a "POP" type operation on our linked list.
If they unsubclass in the wrong order, we have a little extra work to do. An outstanding
caller might still want to call via this (now invalid) godotID! To solve this problem, we
do not delete anything in this case but simply NULL out the userLpfn for this GODOTWND.
Then any time they are looking to call a godotID with no userLpfn, we simply skip down to
the first valid wndproc we can find.
Sometimes, the wndproc we need to call is expecting ANSI. Perhaps they subclassed via
SetWindowLongA, or perhaps it is the original wndproc of a system class (so that the actual
wndproc comes from user32.dll or worse from user.exe!). Therefore we store whether the
prop is expecting Unicode or ANSI values.
Functions found in this file:
InitWindow
CleanupWindow
GetWindowLongInternal
SetWindowLongInternal
FauxWndProcOfHwnd
GetUnicodeWindowProp
DoesWndprocExpectAnsi
WndprocFromFauxWndproc
IsSystemClass
CWnd
Revision History:
28 Feb 2001 v-michka Created.
--*/
#include "precomp.h"
//
// The wnd structure. We store a linked list of these, per window.
// In our most optimal case, this is a list with just one wnd in it.
// WARNING: This structure should be DWORD-aligned!
// WARNING: Do not ever change this structure in a way that would break old clients!!!
//
struct GODOTWND
{
WNDPROC userLpfn; // the lpfn to be calling
UINT godotID; // the fake pointer we hand to the user
BYTE fUnicode : 1; // Is the user lpfn expecting Unicode? All but system wndprocs should
BYTE fWndproc : 1; // wndproc or dlgproc in the userLpfn member?
BYTE bVersion : 8; // Version of the structure, will be 0 for now.
ULONG Reserved : 22; // RESERVED for future use
struct GODOTWND* next; // Pointer to the next GODOTWND to chain to
};
// We keep UNICODE and ANSI versions of this string for ease of comparison.
// Since we never support the user mucking with (or even seeing!) these
// properties, and we do not want to have to convert the string just to
// support the comparisons that we have to do.
// WARNING: You must keep these two strings in synch!!!
const char m_szMemBlock[] = "GodotMemoryBlock";
const WCHAR m_wzMemBlock[] = L"GodotMemoryBlock";
ATOM m_aMemBlock;
const WCHAR c_wzCaptureClass[] = L"ClsCapWin";
const WCHAR c_wzOleaut32Class[] = L"OLEAUT32";
// our own hack ANSI class
#define ANSIWINDOWCLASS (LPWSTR)0x00000001
// some external forward declares
int __stdcall GodotGetClassNameW(HWND hWnd, LPWSTR lpClassName, int nMaxCount);
// our forward declares
/*BOOL IsAnAnsiClass(LPCWSTR lpszClass);*/
int CWnd(struct GODOTWND* head);
/*-------------------------------
IsInternalWindowProperty
// If this is our special wnd prop for the memory
// handle, return FALSE
-------------------------------*/
BOOL IsInternalWindowProperty(LPCWSTR lpsz, BOOL fUnicode)
{
if(FSTRING_VALID(lpsz))
{
if(fUnicode)
return(CompareHelper((LPCWSTR)m_wzMemBlock, lpsz, FALSE) == 0);
else
return((lstrcmpiA((LPCSTR)m_szMemBlock, (LPCSTR)lpsz) == 0));
}
else
return(MAKEINTATOM(lpsz) == MAKEINTATOM(m_aMemBlock));
}
/*-------------------------------
InitWindow
Create the first GODOTWND for the window. Assumes that the lpfn passed
in is (in fact) the subclass.
We use lpszClass to find out whether this is an ANSI or a Unicode window:
1) If the caller passes ANSIWINDOWCLASS then we are sure it is ANSI
2) If the caller is being lazy and passes NULL, then we find out the class name
3) If they pass the class name, we check it
NOTE: We do not put critical sections here because only the
creating thread of a window can ever really initialize
the window with us. Kind of a built-in guard.
-------------------------------*/
BOOL InitWindow(HWND hwnd, LPCWSTR lpszClass)
{
if(GetPropA(hwnd, m_szMemBlock) != 0)
{
// Why get called twice? The only case where this ought
// to happen is child controls of dialogs that are created
// by the caller prior to WM_INITDIALOG. We can just skip
// out in that case.
return(FALSE);
}
else
{
BOOL fUnicode = TRUE;
struct GODOTWND* newWnd;
if(!FSTRING_VALID(lpszClass))
{
// no class name given; lets get it the hard way
WCHAR * wzClassName[128]; // ATOM max is 255 bytes
int cchClassName;
ZeroMemory((LPWSTR)wzClassName, 128);
cchClassName = GodotGetClassNameW(hwnd, (LPWSTR)wzClassName, 128);
wzClassName[cchClassName - 1] = 0;
if(lpszClass == ANSIWINDOWCLASS)
{
// This is our hack flag that indicates that the caller
// is assuring us that this is an ANSI wndproc.
if(gwcscmp(c_wzOleaut32Class, (LPWSTR)wzClassName) == 0)
{
// The un-subclass-able window
return(FALSE);
}
fUnicode = FALSE;
}
else
{
if(gwcscmp(c_wzCaptureClass, (LPWSTR)wzClassName) == 0)
{
// Its a capture window, so lets remember this for all time
SetCaptureWindowProp(hwnd);
}
fUnicode = TRUE;
}
}
newWnd = GodotHeapAlloc(sizeof(struct GODOTWND));
if(newWnd)
{
newWnd->fWndproc = TRUE;
newWnd->godotID = ZEORETHGODOTWND - 1;
// Do the subclass
newWnd->userLpfn = (WNDPROC)SetWindowLongA(hwnd, GWL_WNDPROC, (LONG)&WindowProc);
// Is this a Unicode proc? Well, it is if we have
// not already decided it is an ANSI proc and if
// the actual proc is in the upper 2gb of virtual
// mem reserved for the system.
// CONSIDER: This assumption might suck if a true
// system component ever used Godot!
newWnd->fUnicode = (BYTE)(fUnicode && ((UINT)newWnd->userLpfn < LOWESTSYSMEMLOC));
newWnd->next = NULL;
// We have to aggressively refcount our prop to keep anyone from
// losing it. Thus we do an initial GlobalAddAtom on it and then
// subsequently call SetPropA on it with the same string.
if(!m_aMemBlock)
m_aMemBlock = GlobalAddAtomA(m_szMemBlock);
// Tag the window with the prop that
// contains our GODOTWND linked list
if(SetPropA(hwnd, m_szMemBlock, (HANDLE)newWnd))
{
return(TRUE);
}
}
// If we make it here, then something crucial failed
if(newWnd)
GodotHeapFree(newWnd);
return(FALSE);
}
}
/*-------------------------------
CleanupWindow
We need to make sure we get rid of all the members of
the linked list that we alloc'ed. The window is being
destroyed.
-------------------------------*/
BOOL CleanupWindow(HWND hwnd)
{
struct GODOTWND* current;
struct GODOTWND* next;
BOOL RetVal;
__try
{
EnterCriticalSection(&g_csWnds);
current = GetPropA(hwnd, m_szMemBlock);
while (current != NULL)
{
next = current->next;
GodotHeapFree(current);
current = next;
}
// If this is a common dlg, then the prop must be removed.
RemoveComdlgPropIfPresent(hwnd);
// We must do this remove; if not, then we will be causing the
// prop to be cleaned up by the system and will ruin the other
// windows out there.
RetVal = (RemovePropA(hwnd, m_szMemBlock) != NULL);
}
__finally
{
LeaveCriticalSection(&g_csWnds);
}
return(RetVal);
}
/*-------------------------------
GetWindowLongInternal
Our own internal version of GetWindowLong, which returns a godotID for both WNDPROC and
DLGPROC subclasses. If the window is not one of ours, then we just yield to the actual
GetWindowLong. If, however, it is one our windows but we do not have a subclass in place
(should only be possible for cases such as nIndex==DWL_DLGPROC on non-dialogs) then we
return 0 and set last error to ERROR_INVALID_INDEX, just like the API would do.
-------------------------------*/
LONG GetWindowLongInternal(HWND hwnd, int nIndex, BOOL fUnicode)
{
if(nIndex==GWL_WNDPROC || nIndex==DWL_DLGPROC)
{
struct GODOTWND* current;
LONG RetVal = 0;
__try
{
EnterCriticalSection(&g_csWnds);
current = GetPropA(hwnd, m_szMemBlock);
if(current == NULL)
{
// No list, so we assume this is not one of our windows
RetVal = GetWindowLongA(hwnd, nIndex);
}
else
{
// The top relevant proc must always be valid, so we
// can just return it. Note that we always return the
// GodotID, for both dlgprocs and wndprocs.
while(current)
{
if(((nIndex==GWL_WNDPROC) && current->fWndproc) ||
((nIndex==DWL_DLGPROC) && !current->fWndproc))
{
RetVal = (LONG)current->godotID;
break;
}
current = current->next;
}
}
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
RetVal = 0;
}
LeaveCriticalSection(&g_csWnds);
if(RetVal==0)
SetLastError(ERROR_INVALID_INDEX);
return(RetVal);
}
else
{
// No wrapper needed for non-wndproc calls
return(GetWindowLongA(hwnd, nIndex));
}
}
/*-------------------------------
SetWindowLongInternal
Our own internal version of SetWindowLong, which does the right thing with subclassing both
WNDPROCs and DLGPROCs. Note that the only time we ever *change* the actual subclass that
Windows knows of is when someone subclasses a window that we did not create. Then in the case
of a SetWindowLongA call we just leave it to the API, or in the SetWindowLongW case we hook
up the window, starting with an ANSI proc (which is what should be there now). Otherwise, our
own wndproc is already in charge and the only thing that we do is shuffle who we plan to
call later.
We always return real WNDPROCs when removing a subclass, and godotIDs when adding one.
-------------------------------*/
LONG SetWindowLongInternal(HWND hwnd, int nIndex, LONG dwNewLong, BOOL fUnicode)
{
if(nIndex==GWL_WNDPROC || nIndex==DWL_DLGPROC)
{
struct GODOTWND* head;
LONG RetVal;
BOOL fWndproc; // wndproc or dlgproc?
DWORD dwProcessId = 0;
GetWindowThreadProcessId(hwnd, &dwProcessId);
if(GetCurrentProcessId() != dwProcessId)
{
// Not legal to cross the process boundary on a subclass
SetLastError(ERROR_INVALID_WINDOW_HANDLE);
return(0);
}
// No one can muck with wndprocs until we are done here
EnterCriticalSection(&g_csWnds);
RetVal = 0;
fWndproc = (nIndex==GWL_WNDPROC);
head = GetPropA(hwnd, m_szMemBlock);
if(head == NULL)
{
// No list, so assume this is not (yet?) one of our windows.
// If they called SetWindowLongA then we will yield to the API's wisdom.
if(!fUnicode)
{
RetVal = SetWindowLongA(hwnd, nIndex, dwNewLong);
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
// We will now try hook up this ANSI window
if(!InitWindow(hwnd, ANSIWINDOWCLASS))
{
// Window init failed, so we need to fail the subclass.
SetLastError(ERROR_OUTOFMEMORY);
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
else
{
// This is a new subclass proc! We will create a Unicode
// one atop the ANSI one that was just created.
struct GODOTWND* current = GodotHeapAlloc(sizeof(struct GODOTWND));
if(current == NULL)
{
// Cannot allocate, so bail.
CleanupWindow(hwnd);
SetLastError(ERROR_OUTOFMEMORY);
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
else
{
head = GetPropA(hwnd, m_szMemBlock);
// Lets fill up the new structure
current->userLpfn = (WNDPROC)dwNewLong;
current->fWndproc = (BYTE)fWndproc;
current->godotID = ZEORETHGODOTWND - (CWnd(head) + 1);
current->fUnicode = (BYTE)fUnicode;
current->next = head;
SetPropA(hwnd, m_szMemBlock, (HANDLE)current);
RetVal = current->next->godotID;
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
}
}
else
{
if(INSIDE_GODOT_RANGE(dwNewLong))
{
// This is one of our faux windows, so they are unsubclassing.
struct GODOTWND* current = head;
struct GODOTWND* next = current->next;
if((next != NULL) &&
(next->godotID == dwNewLong) &&
(next->fWndproc == fWndproc))
{
// Must handle the "head" case separately:
// basically it's just a pop operation.
RetVal = (LONG)current->userLpfn;
GodotHeapFree(current);
// CONSIDER: If they unsubclassed out of order, then
// this next godotID might not be valid. We could
// clean up this (next->userLpfn == NULL) case now?
SetPropA(hwnd, m_szMemBlock, (HANDLE)next);
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
while(current != NULL)
{
next = current->next;
// Make sure there is a "next" wndproc, that it is
// both the proc and proctypethat we want
if((next != NULL) &&
(next->godotID == dwNewLong) &&
(next->fWndproc == fWndproc))
{
// We do not free it up since it is not at the head.
// It will be zombied by having a NULL userLpfn.
RetVal = (LONG)next->userLpfn;
current->userLpfn = NULL;
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
current = current->next;
}
// We never found it. Let the user know their call failed.
// Note that this will handle cases we could have detected
// such as trying to unsubclass the true head, trying to
// unsubclass a dlgproc with a wndproc nIndex, etc. Since
// they all get the same error, there was just no need.
SetLastError(ERROR_INVALID_PARAMETER);
RetVal = 0;
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
else
{
// This is a new subclass proc!
struct GODOTWND* current = GodotHeapAlloc(sizeof(struct GODOTWND));
if(current == NULL)
{
// Cannot allocate, so bail.
SetLastError(ERROR_OUTOFMEMORY);
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
else
{
// The original subclass window stays the same, we just put the
// new info into the linked list. We basically just do a push
// on it so it is at the head. The extra SetProp here will keep
// us from (hopefully) running into Win9x property bugs.
current->userLpfn = (WNDPROC)dwNewLong;
current->fWndproc = (BYTE)fWndproc;
current->godotID = ZEORETHGODOTWND - (CWnd(head) + 1);
current->fUnicode = (BYTE)fUnicode;
current->next = head;
SetPropA(hwnd, m_szMemBlock, (HANDLE)current);
// Ok, make sure we return the right previous proc
// based on what type of proc they asked to replace.
current = current->next;
while(current)
{
if((fWndproc == current->fWndproc) &&
(current->userLpfn))
{
RetVal = (LONG)current->godotID;
break;
}
current = current->next;
}
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
}
}
}
else
{
// Its not even for a wndproc, so we will just ask the OS
return(SetWindowLongA(hwnd, nIndex, dwNewLong));
}
}
/*-------------------------------
GetUnicodeWindowProp
Returns TRUE if this window has
the UNICODE window prop set.
-------------------------------*/
BOOL GetUnicodeWindowProp(HWND hwnd)
{
struct GODOTWND* current = GetPropA(hwnd, m_szMemBlock);
return(current != NULL);
}
/*-------------------------------
DoesProcExpectAnsi
Returns TRUE if the proc for the window is the one provided
by the system by default, or if we marked as ANSI for any other
reason. Note that this proc can accept a *real* wndproc rather
than a GodotID here; we detect either case.
-------------------------------*/
BOOL DoesProcExpectAnsi(HWND hwnd, WNDPROC godotID, FAUXPROCTYPE fpt)
{
struct GODOTWND* wnd;
BOOL RetVal = TRUE;
__try
{
EnterCriticalSection(&g_csWnds);
wnd = GetPropA(hwnd, m_szMemBlock);
if(wnd==NULL)
{
RetVal = TRUE;
}
else if(wnd && (godotID == 0))
{
while(wnd != NULL)
{
// UNDONE: What do we do in the (fpt==fptUnknown && godotID==0) case?
if(((fpt==fptWndproc && wnd->fWndproc) ||
(fpt==fptDlgproc && !wnd->fWndproc)) &&
(wnd->userLpfn))
{
RetVal = !wnd->fUnicode;
break;
}
wnd = wnd->next;
}
}
else
{
while(wnd != NULL)
{
if(((INSIDE_GODOT_RANGE(godotID)) && (wnd->godotID == (UINT)godotID)) ||
((OUTSIDE_GODOT_RANGE(godotID)) && wnd->userLpfn == godotID))
{
while(wnd != NULL)
{
if(wnd->userLpfn)
{
RetVal = !wnd->fUnicode;
break;
}
wnd = wnd->next;
}
break;
}
wnd = wnd->next;
}
}
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
RetVal = TRUE;
}
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
/*-------------------------------
WndprocFromFauxWndproc
Given a Godot ID, return a valid wndproc. Returns
the original faux wndproc if it cannot find a valid
real one (probably due to there not being one!).
-------------------------------*/
WNDPROC WndprocFromFauxWndproc(HWND hwnd, WNDPROC fauxLpfn, FAUXPROCTYPE fpt)
{
struct GODOTWND* wnd;
WNDPROC RetVal = fauxLpfn;
__try
{
EnterCriticalSection(&g_csWnds);
wnd = GetPropA(hwnd, m_szMemBlock);
if(fauxLpfn == 0)
{
// A "0" faux lpfn is a signal to just
// pass back the top valid userLpfn.
while(wnd != NULL)
{
if(((fpt==fptWndproc) && (wnd->fWndproc)) ||
((fpt==fptDlgproc) && (!wnd->fWndproc)))
{
RetVal = wnd->userLpfn;
break;
}
wnd = wnd->next;
}
}
else if(OUTSIDE_GODOT_RANGE(fauxLpfn))
{
// Not a faux wndproc, so we will just return
// what was passed in, and assume it is valid
}
else
{
// We iterate through our GODOTWND
// linked list, looking for a match.
while (wnd != NULL)
{
if(wnd->godotID == (UINT)fauxLpfn)
{
// Found it!!! Now we have to make sure it
// is still a valid one (i.e. that user has
// not unsubclassed out of order!)
while ((wnd != NULL) &&
(((fpt==fptWndproc) && (wnd->fWndproc)) ||
((fpt==fptDlgproc) && (!wnd->fWndproc))) ||
((fpt==fptUnknown) && (wnd->userLpfn == NULL)))
wnd=wnd->next;
break;
}
wnd = wnd->next;
}
// If we do not have a wnd at this point, then there was no
// likely candidate, so return the caller's faux wndproc.
// Otherwiwe, pass the one we found.
if(wnd != NULL)
RetVal = wnd->userLpfn;
}
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
RetVal = fauxLpfn;
}
LeaveCriticalSection(&g_csWnds);
return(RetVal);
}
/*-------------------------------
CWnd
How big is this GODOTWND linked list?
-------------------------------*/
int CWnd(struct GODOTWND* head)
{
int count = 0;
struct GODOTWND* current;
current = head;
for (current = head; current != NULL; current = current->next)
{
count++;
}
return(count);
}
/*
// A little system classes struct
struct ANSICLASS {
WCHAR * wzName;
};
// These are all the documented system classes. Also, for Toolbar windows, we
// need to mark the Unicodality as FALSE, since MFC uses the SetWindowText and
// GetWindowText APIs for its custom draw min-caption-like things for floating
// toolbars. This is only the low level wndproc which will get this setting,
// so it should not adversely affect anyone.
// The other common controls are added just in case anyone ELSE overloads msgs
// such as window titles for their own purposes the way that MFC decided to do.
// BASE SYSTEM CLASSES are marked with an asterick.
struct ANSICLASS m_rgwzAnsiClasses[] = {
{L"#32768"}, // *#32768
{L"#32769"}, // *#32769
{L"#32770"}, // *#32770
{L"#32771"}, // *#32771
{WC_BUTTONW}, // *Button
{WC_COMBOBOXW}, // *ComboBox
{WC_COMBOBOXEXW}, // ComboBoxEx32
{L"ComboLBox"}, // *ComboLBox
{WC_EDITW}, // *Edit
{WC_LISTBOXW}, // *ListBox
{L"MDIClient"}, // *MDIClient
{STATUSCLASSNAMEW}, // msctls_statusbar32
{TRACKBAR_CLASSW}, // msctls_trackbar32
{UPDOWN_CLASSW}, // msctls_updown32
{PROGRESS_CLASSW}, // msctls_progress32
{HOTKEY_CLASSW}, // msctls_hotkey32
{REBARCLASSNAMEW}, // ReBarWindow32
{WC_SCROLLBARW}, // *ScrollBar
{WC_STATICW}, // *Static
{WC_PAGESCROLLERW}, // SysPager
{WC_IPADDRESSW}, // SysIPAddress32
{DATETIMEPICK_CLASSW}, // SysDateTimePick32
{MONTHCAL_CLASSW}, // SysMonthCal32
{ANIMATE_CLASSW}, // SysAnimate32
{WC_HEADERW}, // SysHeader32
{WC_LISTVIEWW}, // SysListView32
{WC_TREEVIEWW}, // SysTreeView32
{WC_TABCONTROLW}, // SysTabControl32
{TOOLBARCLASSNAMEW}, // ToolbarWindow32
{TOOLTIPS_CLASSW}, // tooltips_class32
{NULL}
};
//-------------------------------
// IsAnAnsiClass
//
// Returns TRUE if the class is a "system" class (which has
// a default wndproc). Also returns TRUE for other classes
// which need to be marked as "ANSI".
---------------------------------
BOOL IsAnAnsiClass(LPCWSTR lpwz)
{
if(FSTRING_VALID(lpwz))
{
// PERF: We optimize by making sure that the first character matches
// one of the known system classes. Be sure to add the case
// here if you add any classes to m_rgwzAnsiClasses!
switch(*lpwz)
case '#':
case 'B':
case 'b':
case 'C':
case 'c':
case 'E':
case 'e':
case 'L':
case 'l':
case 'M':
case 'm':
case 'R':
case 'S':
case 's':
case 'T':
case 't':
{
int iClass = 0;
while(m_rgwzAnsiClasses[iClass].wzName)
{
if(CompareHelper(lpwz, (LPWSTR)(m_rgwzAnsiClasses[iClass].wzName), FALSE) == 0)
{
return(TRUE);
}
iClass++;
}
break;
}
}
return(FALSE);
}
*/
Reference in a new issue Copy permalink