[wxWidgets.git] / include / wx / msw / winundef.h

/////////////////////////////////////////////////////////////////////////////
// Name:        winundef.h
// Purpose:     undefine the common symbols #define'd by <windows.h>
// Author:      Vadim Zeitlin
// Modified by:
// Created:     16.05.99
// RCS-ID:      $Id$
// Copyright:   (c) wxWidgets team
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

/* THIS SHOULD NOT BE USED since you might include it once e.g. in window.h,
 * then again _AFTER_ you've included windows.h, in which case it won't work
 * a 2nd time -- JACS
#ifndef _WX_WINUNDEF_H_
#define _WX_WINUNDEF_H_
 */

// ----------------------------------------------------------------------------
// windows.h #defines the following identifiers which are also used in wxWin so
// we replace these symbols with the corresponding inline functions and
// undefine the macro.
//
// This looks quite ugly here but allows us to write clear (and correct!) code
// elsewhere because the functions, unlike the macros, respect the scope.
// ----------------------------------------------------------------------------

// CreateDialog

#if defined(CreateDialog)
    #undef CreateDialog

    inline HWND CreateDialog(HINSTANCE hInstance,
                             LPCTSTR pTemplate,
                             HWND hwndParent,
                             DLGPROC pDlgProc)
    {
        #ifdef _UNICODE
            return CreateDialogW(hInstance, pTemplate, hwndParent, pDlgProc);
        #else
            return CreateDialogA(hInstance, pTemplate, hwndParent, pDlgProc);
        #endif
    }
#endif

// CreateFont

#ifdef CreateFont
    #undef CreateFont

    inline HFONT CreateFont(int height,
                            int width,
                            int escapement,
                            int orientation,
                            int weight,
                            DWORD italic,
                            DWORD underline,
                            DWORD strikeout,
                            DWORD charset,
                            DWORD outprecision,
                            DWORD clipprecision,
                            DWORD quality,
                            DWORD family,
                            LPCTSTR facename)
    {
        #ifdef _UNICODE
            return CreateFontW(height, width, escapement, orientation,
                               weight, italic, underline, strikeout, charset,
                               outprecision, clipprecision, quality,
                               family, facename);
        #else
            return CreateFontA(height, width, escapement, orientation,
                               weight, italic, underline, strikeout, charset,
                               outprecision, clipprecision, quality,
                               family, facename);
        #endif
    }
#endif // CreateFont

// CreateWindow

#if defined(CreateWindow)
    #undef CreateWindow

    inline HWND CreateWindow(LPCTSTR lpClassName,
                             LPCTSTR lpWndClass,
                             DWORD dwStyle,
                             int x, int y, int w, int h,
                             HWND hWndParent,
                             HMENU hMenu,
                             HINSTANCE hInstance,
                             LPVOID lpParam)
    {
        #ifdef _UNICODE
            return CreateWindowW(lpClassName, lpWndClass, dwStyle, x, y, w, h,
                                 hWndParent, hMenu, hInstance, lpParam);
        #else
            return CreateWindowA(lpClassName, lpWndClass, dwStyle, x, y, w, h,
                                 hWndParent, hMenu, hInstance, lpParam);
        #endif
    }
#endif

// LoadMenu

#ifdef LoadMenu
    #undef LoadMenu

    inline HMENU LoadMenu(HINSTANCE instance, LPCTSTR name)
    {
        #ifdef _UNICODE
            return LoadMenuW(instance, name);
        #else
            return LoadMenuA(instance, name);
        #endif
    }
#endif

// FindText

#ifdef FindText
    #undef FindText

    inline HWND APIENTRY FindText(LPFINDREPLACE lpfindreplace)
    {
        #ifdef _UNICODE
            return FindTextW(lpfindreplace);
        #else
            return FindTextA(lpfindreplace);
        #endif
    }
#endif

// GetCharWidth

#ifdef GetCharWidth
   #undef GetCharWidth
   inline BOOL  GetCharWidth(HDC dc, UINT first, UINT last, LPINT buffer)
   {
   #ifdef _UNICODE
      return GetCharWidthW(dc, first, last, buffer);
   #else
      return GetCharWidthA(dc, first, last, buffer);
   #endif
   }
#endif

// FindWindow

#ifdef FindWindow
   #undef FindWindow
   #ifdef _UNICODE
   inline HWND FindWindow(LPCWSTR classname, LPCWSTR windowname)
   {
      return FindWindowW(classname, windowname);
   }
   #else
   inline HWND FindWindow(LPCSTR classname, LPCSTR windowname)
   {
      return FindWindowA(classname, windowname);
   }
   #endif
#endif

// PlaySound

#ifdef PlaySound
   #undef PlaySound
   #ifdef _UNICODE
   inline BOOL PlaySound(LPCWSTR pszSound, HMODULE hMod, DWORD fdwSound)
   {
      return PlaySoundW(pszSound, hMod, fdwSound);
   }
   #else
   inline BOOL PlaySound(LPCSTR pszSound, HMODULE hMod, DWORD fdwSound)
   {
      return PlaySoundA(pszSound, hMod, fdwSound);
   }
   #endif
#endif

// GetClassName

#ifdef GetClassName
   #undef GetClassName
   #ifdef _UNICODE
   inline int GetClassName(HWND h, LPWSTR classname, int maxcount)
   {
      return GetClassNameW(h, classname, maxcount);
   }
   #else
   inline int GetClassName(HWND h, LPSTR classname, int maxcount)
   {
      return GetClassNameA(h, classname, maxcount);
   }
   #endif
#endif

// GetClassInfo

#ifdef GetClassInfo
   #undef GetClassInfo
   #ifdef _UNICODE
   inline BOOL GetClassInfo(HINSTANCE h, LPCWSTR name, LPWNDCLASSW winclass)
   {
      return GetClassInfoW(h, name, winclass);
   }
   #else
   inline BOOL GetClassInfo(HINSTANCE h, LPCSTR name, LPWNDCLASSA winclass)
   {
      return GetClassInfoA(h, name, winclass);
   }
   #endif
#endif

// LoadAccelerators

#ifdef LoadAccelerators
   #undef LoadAccelerators
   #ifdef _UNICODE
   inline HACCEL LoadAccelerators(HINSTANCE h, LPCWSTR name)
   {
      return LoadAcceleratorsW(h, name);
   }
   #else
   inline HACCEL LoadAccelerators(HINSTANCE h, LPCSTR name)
   {
      return LoadAcceleratorsA(h, name);
   }
   #endif
#endif

// DrawText

#ifdef DrawText
   #undef DrawText
   #ifdef _UNICODE
   inline int DrawText(HDC h, LPCWSTR str, int count, LPRECT rect, UINT format)
   {
      return DrawTextW(h, str, count, rect, format);
   }
   #else
   inline int DrawText(HDC h, LPCSTR str, int count, LPRECT rect, UINT format)
   {
      return DrawTextA(h, str, count, rect, format);
   }
   #endif
#endif


// StartDoc

#ifdef StartDoc
   #undef StartDoc
   #if defined( __GNUG__ ) && !wxCHECK_W32API_VERSION( 0, 5 )
      #define DOCINFOW DOCINFO
      #define DOCINFOA DOCINFO
   #endif
   #ifdef _UNICODE
   inline int StartDoc(HDC h, CONST DOCINFOW* info)
   {
      return StartDocW(h, (DOCINFOW*) info);
   }
   #else
   inline int StartDoc(HDC h, CONST DOCINFOA* info)
   {
      return StartDocA(h, (DOCINFOA*) info);
   }
   #endif
#endif

// GetObject

#ifdef GetObject
   #undef GetObject
   inline int GetObject(HGDIOBJ h, int i, LPVOID buffer)
   {
   #ifdef _UNICODE
      return GetObjectW(h, i, buffer);
   #else
      return GetObjectA(h, i, buffer);
   #endif
   }
#endif

// GetMessage

#ifdef GetMessage
   #undef GetMessage
   inline int GetMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)
   {
   #ifdef _UNICODE
      return GetMessageW(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
   #else
      return GetMessageA(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
   #endif
   }
#endif

// LoadIcon
#ifdef LoadIcon
    #undef LoadIcon
    inline HICON LoadIcon(HINSTANCE hInstance, LPCTSTR lpIconName)
    {
        #ifdef _UNICODE
            return LoadIconW(hInstance, lpIconName);
        #else // ANSI
            return LoadIconA(hInstance, lpIconName);
        #endif // Unicode/ANSI
    }
#endif // LoadIcon

// LoadBitmap
#ifdef LoadBitmap
    #undef LoadBitmap
    inline HBITMAP LoadBitmap(HINSTANCE hInstance, LPCTSTR lpBitmapName)
    {
        #ifdef _UNICODE
            return LoadBitmapW(hInstance, lpBitmapName);
        #else // ANSI
            return LoadBitmapA(hInstance, lpBitmapName);
        #endif // Unicode/ANSI
    }
#endif // LoadBitmap

// LoadLibrary

#ifdef LoadLibrary
    #undef LoadLibrary
    #ifdef _UNICODE
    inline HINSTANCE LoadLibrary(LPCWSTR lpLibFileName)
    {
        return LoadLibraryW(lpLibFileName);
    }
    #else
    inline HINSTANCE LoadLibrary(LPCSTR lpLibFileName)
    {
        return LoadLibraryA(lpLibFileName);
    }
    #endif
#endif

// FindResource
#ifdef FindResource
    #undef FindResource
    #ifdef _UNICODE
    inline HRSRC FindResource(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType)
    {
        return FindResourceW(hModule, lpName, lpType);
    }
    #else
    inline HRSRC FindResource(HMODULE hModule, LPCSTR lpName, LPCSTR lpType)
    {
        return FindResourceA(hModule, lpName, lpType);
    }
    #endif
#endif

// IsMaximized

#ifdef IsMaximized
    #undef IsMaximized
    inline BOOL IsMaximized(HWND WXUNUSED_IN_WINCE(hwnd))
    {
#ifdef __WXWINCE__
        return FALSE;
#else
        return IsZoomed(hwnd);
#endif
    }
#endif

// GetFirstChild

#ifdef GetFirstChild
    #undef GetFirstChild
    inline HWND GetFirstChild(HWND WXUNUSED_IN_WINCE(hwnd))
    {
#ifdef __WXWINCE__
        return 0;
#else
        return GetTopWindow(hwnd);
#endif
    }
#endif

// GetFirstSibling

#ifdef GetFirstSibling
    #undef GetFirstSibling
    inline HWND GetFirstSibling(HWND hwnd)
    {
        return GetWindow(hwnd,GW_HWNDFIRST);
    }
#endif

// GetLastSibling

#ifdef GetLastSibling
    #undef GetLastSibling
    inline HWND GetLastSibling(HWND hwnd)
    {
        return GetWindow(hwnd,GW_HWNDLAST);
    }
#endif

// GetPrevSibling

#ifdef GetPrevSibling
    #undef GetPrevSibling
    inline HWND GetPrevSibling(HWND hwnd)
    {
        return GetWindow(hwnd,GW_HWNDPREV);
    }
#endif

// GetNextSibling

#ifdef GetNextSibling
    #undef GetNextSibling
    inline HWND GetNextSibling(HWND hwnd)
    {
        return GetWindow(hwnd,GW_HWNDNEXT);
    }
#endif

// For WINE

#if defined(GetWindowStyle)
  #undef GetWindowStyle
#endif

// For ming and cygwin

// GetFirstChild
#ifdef GetFirstChild
   #undef GetFirstChild
   inline HWND GetFirstChild(HWND h)
   {
      return GetTopWindow(h);
   }
#endif


// GetNextSibling
#ifdef GetNextSibling
   #undef GetNextSibling
   inline HWND GetNextSibling(HWND h)
   {
     return GetWindow(h, GW_HWNDNEXT);
   }
#endif


#ifdef Yield
    #undef Yield
#endif


#if defined(__WXWINCE__) && defined(DrawIcon) //#ifdef DrawIcon
    #undef DrawIcon
    inline BOOL DrawIcon(HDC hdc, int x, int y, HICON hicon)
    {
        return DrawIconEx(hdc,x,y,hicon,0,0,0,NULL, DI_NORMAL) ;
    }
#endif


// GetWindowProc
//ifdef GetWindowProc
//   #undef GetWindowProc
//endif
//ifdef GetNextChild
//    #undef GetNextChild
//endif

// #endif // _WX_WINUNDEF_H_
Commit	Line	Data
98216d40 VZ	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: winundef.h
	3	// Purpose: undefine the common symbols #define'd by <windows.h>
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 16.05.99
	7	// RCS-ID: $Id$
77ffb593	8	// Copyright: (c) wxWidgets team
65571936	9	// Licence: wxWindows licence
98216d40 VZ	10	/////////////////////////////////////////////////////////////////////////////
98216d40 VZ	11
25889d3c JS	12	/* THIS SHOULD NOT BE USED since you might include it once e.g. in window.h,
	13	* then again _AFTER_ you've included windows.h, in which case it won't work
	14	* a 2nd time -- JACS
98216d40 VZ	15	#ifndef _WX_WINUNDEF_H_
98216d40 VZ	16	#define _WX_WINUNDEF_H_
25889d3c	17	*/
98216d40	18
7cc98b3e VZ	19	// ----------------------------------------------------------------------------
	20	// windows.h #defines the following identifiers which are also used in wxWin so
	21	// we replace these symbols with the corresponding inline functions and
	22	// undefine the macro.
	23	//
	24	// This looks quite ugly here but allows us to write clear (and correct!) code
	25	// elsewhere because the functions, unlike the macros, respect the scope.
	26	// ----------------------------------------------------------------------------
6bbd3344	27
b225f659 VZ	28	// CreateDialog
b225f659 VZ	29
fb86251b	30	#if defined(CreateDialog)
b225f659 VZ	31	#undef CreateDialog
	32
	33	inline HWND CreateDialog(HINSTANCE hInstance,
	34	LPCTSTR pTemplate,
	35	HWND hwndParent,
	36	DLGPROC pDlgProc)
	37	{
	38	#ifdef _UNICODE
	39	return CreateDialogW(hInstance, pTemplate, hwndParent, pDlgProc);
	40	#else
	41	return CreateDialogA(hInstance, pTemplate, hwndParent, pDlgProc);
	42	#endif
	43	}
	44	#endif
	45
136b3b19 VZ	46	// CreateFont
	47
	48	#ifdef CreateFont
	49	#undef CreateFont
	50
	51	inline HFONT CreateFont(int height,
	52	int width,
	53	int escapement,
	54	int orientation,
	55	int weight,
	56	DWORD italic,
	57	DWORD underline,
	58	DWORD strikeout,
	59	DWORD charset,
	60	DWORD outprecision,
	61	DWORD clipprecision,
	62	DWORD quality,
	63	DWORD family,
	64	LPCTSTR facename)
	65	{
	66	#ifdef _UNICODE
	67	return CreateFontW(height, width, escapement, orientation,
	68	weight, italic, underline, strikeout, charset,
	69	outprecision, clipprecision, quality,
	70	family, facename);
	71	#else
	72	return CreateFontA(height, width, escapement, orientation,
	73	weight, italic, underline, strikeout, charset,
	74	outprecision, clipprecision, quality,
	75	family, facename);
	76	#endif
	77	}
	78	#endif // CreateFont
	79
7344726a VZ	80	// CreateWindow
	81
	82	#if defined(CreateWindow)
	83	#undef CreateWindow
	84
	85	inline HWND CreateWindow(LPCTSTR lpClassName,
	86	LPCTSTR lpWndClass,
	87	DWORD dwStyle,
	88	int x, int y, int w, int h,
	89	HWND hWndParent,
	90	HMENU hMenu,
	91	HINSTANCE hInstance,
	92	LPVOID lpParam)
	93	{
	94	#ifdef _UNICODE
	95	return CreateWindowW(lpClassName, lpWndClass, dwStyle, x, y, w, h,
	96	hWndParent, hMenu, hInstance, lpParam);
	97	#else
	98	return CreateWindowA(lpClassName, lpWndClass, dwStyle, x, y, w, h,
	99	hWndParent, hMenu, hInstance, lpParam);
	100	#endif
	101	}
	102	#endif
	103
731db709 VZ	104	// LoadMenu
	105
	106	#ifdef LoadMenu
	107	#undef LoadMenu
	108
	109	inline HMENU LoadMenu(HINSTANCE instance, LPCTSTR name)
	110	{
	111	#ifdef _UNICODE
	112	return LoadMenuW(instance, name);
	113	#else
	114	return LoadMenuA(instance, name);
	115	#endif
	116	}
	117	#endif
	118
2b5f62a0 VZ	119	// FindText
	120
	121	#ifdef FindText
	122	#undef FindText
	123
	124	inline HWND APIENTRY FindText(LPFINDREPLACE lpfindreplace)
	125	{
5d779223	126	#ifdef _UNICODE
2b5f62a0 VZ	127	return FindTextW(lpfindreplace);
	128	#else
	129	return FindTextA(lpfindreplace);
5d779223	130	#endif
2b5f62a0 VZ	131	}
	132	#endif
	133
6bbd3344 BM	134	// GetCharWidth
6bbd3344 BM	135
98216d40	136	#ifdef GetCharWidth
379a3b04 BM	137	#undef GetCharWidth
	138	inline BOOL GetCharWidth(HDC dc, UINT first, UINT last, LPINT buffer)
	139	{
	140	#ifdef _UNICODE
	141	return GetCharWidthW(dc, first, last, buffer);
	142	#else
	143	return GetCharWidthA(dc, first, last, buffer);
	144	#endif
	145	}
e90babdf	146	#endif
6bbd3344 BM	147
	148	// FindWindow
	149
98216d40	150	#ifdef FindWindow
379a3b04 BM	151	#undef FindWindow
	152	#ifdef _UNICODE
	153	inline HWND FindWindow(LPCWSTR classname, LPCWSTR windowname)
	154	{
	155	return FindWindowW(classname, windowname);
	156	}
	157	#else
	158	inline HWND FindWindow(LPCSTR classname, LPCSTR windowname)
	159	{
	160	return FindWindowA(classname, windowname);
	161	}
	162	#endif
e90babdf	163	#endif
6bbd3344	164
13ff9344 JS	165	// PlaySound
	166
	167	#ifdef PlaySound
	168	#undef PlaySound
	169	#ifdef _UNICODE
	170	inline BOOL PlaySound(LPCWSTR pszSound, HMODULE hMod, DWORD fdwSound)
	171	{
	172	return PlaySoundW(pszSound, hMod, fdwSound);
	173	}
	174	#else
	175	inline BOOL PlaySound(LPCSTR pszSound, HMODULE hMod, DWORD fdwSound)
	176	{
	177	return PlaySoundA(pszSound, hMod, fdwSound);
	178	}
	179	#endif
	180	#endif
	181
6bbd3344 BM	182	// GetClassName
6bbd3344 BM	183
98216d40	184	#ifdef GetClassName
379a3b04 BM	185	#undef GetClassName
	186	#ifdef _UNICODE
	187	inline int GetClassName(HWND h, LPWSTR classname, int maxcount)
	188	{
	189	return GetClassNameW(h, classname, maxcount);
	190	}
	191	#else
	192	inline int GetClassName(HWND h, LPSTR classname, int maxcount)
	193	{
	194	return GetClassNameA(h, classname, maxcount);
	195	}
	196	#endif
e90babdf	197	#endif
6bbd3344 BM	198
	199	// GetClassInfo
	200
98216d40	201	#ifdef GetClassInfo
379a3b04 BM	202	#undef GetClassInfo
	203	#ifdef _UNICODE
	204	inline BOOL GetClassInfo(HINSTANCE h, LPCWSTR name, LPWNDCLASSW winclass)
	205	{
	206	return GetClassInfoW(h, name, winclass);
	207	}
	208	#else
	209	inline BOOL GetClassInfo(HINSTANCE h, LPCSTR name, LPWNDCLASSA winclass)
	210	{
	211	return GetClassInfoA(h, name, winclass);
	212	}
	213	#endif
e90babdf	214	#endif
6bbd3344 BM	215
	216	// LoadAccelerators
	217
98216d40	218	#ifdef LoadAccelerators
379a3b04 BM	219	#undef LoadAccelerators
	220	#ifdef _UNICODE
	221	inline HACCEL LoadAccelerators(HINSTANCE h, LPCWSTR name)
	222	{
	223	return LoadAcceleratorsW(h, name);
	224	}
	225	#else
	226	inline HACCEL LoadAccelerators(HINSTANCE h, LPCSTR name)
	227	{
	228	return LoadAcceleratorsA(h, name);
	229	}
	230	#endif
98216d40	231	#endif
6bbd3344 BM	232
	233	// DrawText
	234
98216d40	235	#ifdef DrawText
379a3b04 BM	236	#undef DrawText
	237	#ifdef _UNICODE
	238	inline int DrawText(HDC h, LPCWSTR str, int count, LPRECT rect, UINT format)
	239	{
	240	return DrawTextW(h, str, count, rect, format);
	241	}
	242	#else
	243	inline int DrawText(HDC h, LPCSTR str, int count, LPRECT rect, UINT format)
	244	{
	245	return DrawTextA(h, str, count, rect, format);
	246	}
	247	#endif
e90babdf	248	#endif
6bbd3344	249
4ccf704a	250
6bbd3344 BM	251	// StartDoc
6bbd3344 BM	252
98216d40	253	#ifdef StartDoc
379a3b04	254	#undef StartDoc
d8c72298	255	#if defined( __GNUG__ ) && !wxCHECK_W32API_VERSION( 0, 5 )
0c589ad0 BM	256	#define DOCINFOW DOCINFO
	257	#define DOCINFOA DOCINFO
	258	#endif
379a3b04 BM	259	#ifdef _UNICODE
	260	inline int StartDoc(HDC h, CONST DOCINFOW* info)
	261	{
d8c72298	262	return StartDocW(h, (DOCINFOW*) info);
379a3b04 BM	263	}
	264	#else
	265	inline int StartDoc(HDC h, CONST DOCINFOA* info)
	266	{
d8c72298	267	return StartDocA(h, (DOCINFOA*) info);
379a3b04 BM	268	}
379a3b04 BM	269	#endif
98216d40 VZ	270	#endif
98216d40 VZ	271
379a3b04 BM	272	// GetObject
	273
	274	#ifdef GetObject
	275	#undef GetObject
	276	inline int GetObject(HGDIOBJ h, int i, LPVOID buffer)
	277	{
	278	#ifdef _UNICODE
	279	return GetObjectW(h, i, buffer);
	280	#else
	281	return GetObjectA(h, i, buffer);
6ec9d18f RD	282	#endif
	283	}
	284	#endif
	285
7cc98b3e	286	// GetMessage
6ec9d18f RD	287
	288	#ifdef GetMessage
	289	#undef GetMessage
	290	inline int GetMessage(LPMSG lpMsg, HWND hWnd, UINT wMsgFilterMin, UINT wMsgFilterMax)
	291	{
	292	#ifdef _UNICODE
	293	return GetMessageW(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
	294	#else
	295	return GetMessageA(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
	296	#endif
379a3b04	297	}
e90babdf	298	#endif
98216d40	299
8b39c006 VZ	300	// LoadIcon
	301	#ifdef LoadIcon
	302	#undef LoadIcon
5e2411ab	303	inline HICON LoadIcon(HINSTANCE hInstance, LPCTSTR lpIconName)
8b39c006 VZ	304	{
	305	#ifdef _UNICODE
	306	return LoadIconW(hInstance, lpIconName);
	307	#else // ANSI
	308	return LoadIconA(hInstance, lpIconName);
	309	#endif // Unicode/ANSI
	310	}
	311	#endif // LoadIcon
	312
381adb74 VZ	313	// LoadBitmap
	314	#ifdef LoadBitmap
	315	#undef LoadBitmap
	316	inline HBITMAP LoadBitmap(HINSTANCE hInstance, LPCTSTR lpBitmapName)
	317	{
	318	#ifdef _UNICODE
	319	return LoadBitmapW(hInstance, lpBitmapName);
	320	#else // ANSI
	321	return LoadBitmapA(hInstance, lpBitmapName);
	322	#endif // Unicode/ANSI
	323	}
	324	#endif // LoadBitmap
8b39c006	325
7cc98b3e VZ	326	// LoadLibrary
	327
	328	#ifdef LoadLibrary
	329	#undef LoadLibrary
7cc98b3e	330	#ifdef _UNICODE
f6bcfd97 BP	331	inline HINSTANCE LoadLibrary(LPCWSTR lpLibFileName)
f6bcfd97 BP	332	{
7cc98b3e	333	return LoadLibraryW(lpLibFileName);
f6bcfd97	334	}
7cc98b3e	335	#else
f6bcfd97 BP	336	inline HINSTANCE LoadLibrary(LPCSTR lpLibFileName)
f6bcfd97 BP	337	{
7cc98b3e	338	return LoadLibraryA(lpLibFileName);
7cc98b3e	339	}
f6bcfd97	340	#endif
7cc98b3e VZ	341	#endif
7cc98b3e VZ	342
b568d04f VZ	343	// FindResource
	344	#ifdef FindResource
	345	#undef FindResource
b568d04f	346	#ifdef _UNICODE
f6bcfd97 BP	347	inline HRSRC FindResource(HMODULE hModule, LPCWSTR lpName, LPCWSTR lpType)
f6bcfd97 BP	348	{
b568d04f	349	return FindResourceW(hModule, lpName, lpType);
f6bcfd97	350	}
b568d04f	351	#else
f6bcfd97 BP	352	inline HRSRC FindResource(HMODULE hModule, LPCSTR lpName, LPCSTR lpType)
f6bcfd97 BP	353	{
b568d04f	354	return FindResourceA(hModule, lpName, lpType);
b568d04f	355	}
f6bcfd97	356	#endif
b568d04f VZ	357	#endif
b568d04f VZ	358
3372145d PA	359	// IsMaximized
	360
	361	#ifdef IsMaximized
	362	#undef IsMaximized
0c0d1521	363	inline BOOL IsMaximized(HWND WXUNUSED_IN_WINCE(hwnd))
3372145d	364	{
42d11c8e JS	365	#ifdef __WXWINCE__
	366	return FALSE;
	367	#else
3372145d	368	return IsZoomed(hwnd);
42d11c8e	369	#endif
3372145d PA	370	}
	371	#endif
	372
2ba3d4f0 PA	373	// GetFirstChild
	374
	375	#ifdef GetFirstChild
	376	#undef GetFirstChild
0c0d1521	377	inline HWND GetFirstChild(HWND WXUNUSED_IN_WINCE(hwnd))
2ba3d4f0	378	{
42d11c8e JS	379	#ifdef __WXWINCE__
	380	return 0;
	381	#else
2ba3d4f0	382	return GetTopWindow(hwnd);
42d11c8e	383	#endif
2ba3d4f0 PA	384	}
	385	#endif
	386
dec531b2 VS	387	// GetFirstSibling
	388
	389	#ifdef GetFirstSibling
	390	#undef GetFirstSibling
	391	inline HWND GetFirstSibling(HWND hwnd)
	392	{
	393	return GetWindow(hwnd,GW_HWNDFIRST);
	394	}
	395	#endif
	396
	397	// GetLastSibling
	398
	399	#ifdef GetLastSibling
	400	#undef GetLastSibling
	401	inline HWND GetLastSibling(HWND hwnd)
	402	{
	403	return GetWindow(hwnd,GW_HWNDLAST);
	404	}
	405	#endif
	406
79bc2382 PA	407	// GetPrevSibling
	408
	409	#ifdef GetPrevSibling
	410	#undef GetPrevSibling
	411	inline HWND GetPrevSibling(HWND hwnd)
	412	{
	413	return GetWindow(hwnd,GW_HWNDPREV);
	414	}
	415	#endif
	416
	417	// GetNextSibling
	418
	419	#ifdef GetNextSibling
	420	#undef GetNextSibling
	421	inline HWND GetNextSibling(HWND hwnd)
	422	{
	423	return GetWindow(hwnd,GW_HWNDNEXT);
	424	}
	425	#endif
	426
c455ab93 RR	427	// For WINE
c455ab93 RR	428
b4da152e	429	#if defined(GetWindowStyle)
c455ab93 RR	430	#undef GetWindowStyle
c455ab93 RR	431	#endif
98216d40	432
379a3b04	433	// For ming and cygwin
6bbd3344	434
379a3b04 BM	435	// GetFirstChild
	436	#ifdef GetFirstChild
	437	#undef GetFirstChild
	438	inline HWND GetFirstChild(HWND h)
	439	{
	440	return GetTopWindow(h);
	441	}
	442	#endif
6bbd3344	443
98216d40	444
379a3b04 BM	445	// GetNextSibling
379a3b04 BM	446	#ifdef GetNextSibling
0c589ad0 BM	447	#undef GetNextSibling
	448	inline HWND GetNextSibling(HWND h)
	449	{
	450	return GetWindow(h, GW_HWNDNEXT);
	451	}
98216d40 VZ	452	#endif
98216d40 VZ	453
73c13bb9 RD	454
	455	#ifdef Yield
	456	#undef Yield
	457	#endif
	458
368c9c6d JS	459
	460	#if defined(__WXWINCE__) && defined(DrawIcon) //#ifdef DrawIcon
	461	#undef DrawIcon
27d2dbbc	462	inline BOOL DrawIcon(HDC hdc, int x, int y, HICON hicon)
368c9c6d JS	463	{
	464	return DrawIconEx(hdc,x,y,hicon,0,0,0,NULL, DI_NORMAL) ;
	465	}
	466	#endif
	467
	468
379a3b04 BM	469	// GetWindowProc
	470	//ifdef GetWindowProc
	471	// #undef GetWindowProc
	472	//endif
	473	//ifdef GetNextChild
	474	// #undef GetNextChild
	475	//endif
6bbd3344	476
25889d3c JS	477	// #endif // _WX_WINUNDEF_H_
25889d3c JS	478