git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	1	/*
	2	* Name: wx/defs.h
	3	* Purpose: Declarations/definitions common to all wx source files
	4	* Author: Julian Smart and others
	5	* Modified by: Ryan Norton (Converted to C)
	6	* Created: 01/02/97
	7	* RCS-ID: $Id$
	8	* Copyright: (c) Julian Smart
	9	* Licence: wxWindows licence
	10	*/
	11
	12	/* THIS IS A C FILE, DON'T USE C++ FEATURES (IN PARTICULAR COMMENTS) IN IT */
	13
	14	#ifndef _WX_DEFS_H_
	15	#define _WX_DEFS_H_
	16
	17	/* ---------------------------------------------------------------------------- */
	18	/* compiler and OS identification */
	19	/* ---------------------------------------------------------------------------- */
	20
	21	#include "wx/platform.h"
	22
	23	#ifdef __cplusplus
	24	/* Make sure the environment is set correctly */
	25	# if defined(__WXMSW__) && defined(__X__)
	26	# error "Target can't be both X and Windows"
	27	# elif defined(__WXMSW__) && defined(__PALMOS__)
	28	# error "Target can't be both PalmOS and Windows"
	29	# elif !defined(__WXMOTIF__) && \
	30	!defined(__WXMSW__) && \
	31	!defined(__WXPALMOS__)&& \
	32	!defined(__WXGTK__) && \
	33	!defined(__WXPM__) && \
	34	!defined(__WXMAC__) && \
	35	!defined(__WXCOCOA__) && \
	36	!defined(__X__) && \
	37	!defined(__WXMGL__) && \
	38	!defined(__WXDFB__) && \
	39	!defined(__WXX11__) && \
	40	wxUSE_GUI
	41	# ifdef __UNIX__
	42	# error "No Target! You should use wx-config program for compilation flags!"
	43	# else /* !Unix */
	44	# error "No Target! You should use supplied makefiles for compilation!"
	45	# endif /* Unix/!Unix */
	46	# endif
	47	#endif /__cplusplus/
	48
	49	#ifndef __WXWINDOWS__
	50	#define __WXWINDOWS__ 1
	51	#endif
	52
	53	#ifndef wxUSE_BASE
	54	/* by default consider that this is a monolithic build */
	55	#define wxUSE_BASE 1
	56	#endif
	57
	58	#if !wxUSE_GUI && !defined(__WXBASE__)
	59	#define __WXBASE__
	60	#endif
	61
	62	/* include the feature test macros */
	63	#include "wx/features.h"
	64
	65	/* suppress some Visual C++ warnings */
	66	#ifdef __VISUALC__
	67	/* the only "real" warning here is 4244 but there are just too many of them */
	68	/* in our code... one day someone should go and fix them but until then... */
	69	# pragma warning(disable:4097) /* typedef used as class */
	70	# pragma warning(disable:4201) /* nonstandard extension used: nameless struct/union */
	71	# pragma warning(disable:4244) /* conversion from double to float */
	72	# pragma warning(disable:4355) /* 'this' used in base member initializer list */
	73	# pragma warning(disable:4511) /* copy ctor couldn't be generated */
	74	# pragma warning(disable:4512) /* operator=() couldn't be generated */
	75	# pragma warning(disable:4710) /* function not inlined */
	76
	77	/* For VC++ 5.0 for release mode, the warning 'C4702: unreachable code */
	78	/* is buggy, and occurs for code that does actually get executed */
	79	# if !defined __WXDEBUG__ && __VISUALC__ <= 1100
	80	# pragma warning(disable:4702) /* unreachable code */
	81	# endif
	82	/* The VC++ 5.0 warning 'C4003: not enough actual parameters for macro'
	83	* is incompatible with the wxWidgets headers since it is given when
	84	* parameters are empty but not missing. */
	85	# if __VISUALC__ <= 1100
	86	# pragma warning(disable:4003) /* not enough actual parameters for macro */
	87	# endif
	88
	89	/*
	90	VC++ 8 gives a warning when using standard functions such as sprintf,
	91	localtime, ... -- stop this madness, unless the user had already done it
	92	*/
	93	#if __VISUALC__ >= 1400
	94	#ifndef _CRT_SECURE_NO_DEPRECATE
	95	#define _CRT_SECURE_NO_DEPRECATE 1
	96	#endif
	97	#ifndef _CRT_NON_CONFORMING_SWPRINTFS
	98	#define _CRT_NON_CONFORMING_SWPRINTFS 1
	99	#endif
	100	#endif /* VC++ 8 */
	101	#endif /* __VISUALC__ */
	102
	103	/* suppress some Salford C++ warnings */
	104	#ifdef __SALFORDC__
	105	# pragma suppress 353 /* Possible nested comments */
	106	# pragma suppress 593 /* Define not used */
	107	# pragma suppress 61 /* enum has no name (doesn't suppress!) */
	108	# pragma suppress 106 /* unnamed, unused parameter */
	109	# pragma suppress 571 /* Virtual function hiding */
	110	#endif /* __SALFORDC__ */
	111
	112	/* suppress some Borland C++ warnings */
	113	#ifdef __BORLANDC__
	114	# pragma warn -inl /* Functions containing reserved words and certain constructs are not expanded inline */
	115	#endif /* __BORLANDC__ */
	116
	117	/*
	118	g++ gives a warning when a class has private dtor if it has no friends but
	119	this is a perfectly valid situation for a ref-counted class which destroys
	120	itself when its ref count drops to 0, so provide a macro to suppress this
	121	warning
	122	*/
	123	#ifdef __GNUG__
	124	# define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name) \
	125	friend class wxDummyFriendFor ## name;
	126	#else /* !g++ */
	127	# define wxSUPPRESS_GCC_PRIVATE_DTOR_WARNING(name)
	128	#endif
	129
	130	/* ---------------------------------------------------------------------------- */
	131	/* wxWidgets version and compatibility defines */
	132	/* ---------------------------------------------------------------------------- */
	133
	134	#include "wx/version.h"
	135
	136	/* ============================================================================ */
	137	/* non portable C++ features */
	138	/* ============================================================================ */
	139
	140	/* ---------------------------------------------------------------------------- */
	141	/* compiler defects workarounds */
	142	/* ---------------------------------------------------------------------------- */
	143
	144	/*
	145	Digital Unix C++ compiler only defines this symbol for .cxx and .hxx files,
	146	so define it ourselves (newer versions do it for all files, though, and
	147	don't allow it to be redefined)
	148	*/
	149	#if defined(__DECCXX) && !defined(__VMS) && !defined(__cplusplus)
	150	#define __cplusplus
	151	#endif /* __DECCXX */
	152
	153	/* Resolves linking problems under HP-UX when compiling with gcc/g++ */
	154	#if defined(__HPUX__) && defined(__GNUG__)
	155	#define va_list __gnuc_va_list
	156	#endif /* HP-UX */
	157
	158	/* ---------------------------------------------------------------------------- */
	159	/* check for native bool type and TRUE/FALSE constants */
	160	/* ---------------------------------------------------------------------------- */
	161
	162	/* Add more tests here for Windows compilers that already define bool */
	163	/* (under Unix, configure tests for this) */
	164	#ifndef HAVE_BOOL
	165	#if defined( __MWERKS__ )
	166	#if (__MWERKS__ >= 0x1000) && __option(bool)
	167	#define HAVE_BOOL
	168	#endif
	169	#elif defined(__APPLE__) && defined(__APPLE_CC__)
	170	/* Apple bundled gcc supports bool */
	171	#define HAVE_BOOL
	172	#elif defined(__VISUALC__) && (__VISUALC__ == 1020)
	173	/* in VC++ 4.2 the bool keyword is reserved (hence can't be typedefed) */
	174	/* but not implemented, so we must #define it */
	175	#define bool unsigned int
	176	#elif defined(__VISUALC__) && (__VISUALC__ == 1010)
	177	/* For VisualC++ 4.1, we need to define */
	178	/* bool as something between 4.0 & 5.0... */
	179	typedef unsigned int wxbool;
	180	#define bool wxbool
	181	#define HAVE_BOOL
	182	#elif defined(__VISUALC__) && (__VISUALC__ > 1020)
	183	/* VC++ supports bool since 4.2 */
	184	#define HAVE_BOOL
	185	#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x500)
	186	/* Borland 5.0+ supports bool */
	187	#define HAVE_BOOL
	188	#elif wxCHECK_WATCOM_VERSION(1,0)
	189	/* Watcom 11+ supports bool */
	190	#define HAVE_BOOL
	191	#elif defined(__DIGITALMARS__)
	192	/* DigitalMars supports bool */
	193	#define HAVE_BOOL
	194	#elif defined(__GNUWIN32__) \|\| defined(__MINGW32__) \|\| defined(__CYGWIN__)
	195	/* Cygwin supports bool */
	196	#define HAVE_BOOL
	197	#elif defined(__VISAGECPP__)
	198	#if __IBMCPP__ < 400
	199	typedef unsigned long bool;
	200	#define true ((bool)1)
	201	#define false ((bool)0)
	202	#endif
	203	#define HAVE_BOOL
	204	#endif /* compilers */
	205	#endif /* HAVE_BOOL */
	206
	207	#if !defined(__MWERKS__) \|\| !defined(true)
	208	#if !defined(HAVE_BOOL) && !defined(bool) && !defined(VMS)
	209	/* NB: of course, this doesn't replace the standard type, because, for */
	210	/* example, overloading based on bool/int parameter doesn't work and */
	211	/* so should be avoided in portable programs */
	212	typedef unsigned int bool;
	213	#endif /* bool */
	214
	215	/* deal with TRUE/true stuff: we assume that if the compiler supports bool, it */
	216	/* supports true/false as well and that, OTOH, if it does _not_ support bool, */
	217	/* it doesn't support these keywords (this is less sure, in particular VC++ */
	218	/* 4.x could be a problem here) */
	219	#ifndef HAVE_BOOL
	220	#define true ((bool)1)
	221	#define false ((bool)0)
	222	#endif
	223	#endif
	224
	225	/* for backwards compatibility, also define TRUE and FALSE */
	226	/* */
	227	/* note that these definitions should work both in C++ and C code, so don't */
	228	/* use true/false below */
	229	#ifndef TRUE
	230	#define TRUE 1
	231	#endif
	232
	233	#ifndef FALSE
	234	#define FALSE 0
	235	#endif
	236
	237	typedef short int WXTYPE;
	238
	239	/* special care should be taken with this type under Windows where the real */
	240	/* window id is unsigned, so we must always do the cast before comparing them */
	241	/* (or else they would be always different!). Using wxGetWindowId() which does */
	242	/* the cast itself is recommended. Note that this type can't be unsigned */
	243	/* because wxID_ANY == -1 is a valid (and largely used) value for window id. */
	244	typedef int wxWindowID;
	245
	246	/* ---------------------------------------------------------------------------- */
	247	/* other feature tests */
	248	/* ---------------------------------------------------------------------------- */
	249
	250	/* Every ride down a slippery slope begins with a single step.. */
	251	/* */
	252	/* Yes, using nested classes is indeed against our coding standards in */
	253	/* general, but there are places where you can use them to advantage */
	254	/* without totally breaking ports that cannot use them. If you do, then */
	255	/* wrap it in this guard, but such cases should still be relatively rare. */
	256	#define wxUSE_NESTED_CLASSES 1
	257
	258	/* check for explicit keyword support */
	259	#ifndef HAVE_EXPLICIT
	260	#if defined(__VISUALC__) && (__VISUALC__ >= 1100)
	261	/* VC++ 6.0 and 5.0 have explicit (what about earlier versions?) */
	262	#define HAVE_EXPLICIT
	263	#elif ( defined(__MINGW32__) \|\| defined(__CYGWIN32__) ) \
	264	&& wxCHECK_GCC_VERSION(2, 95)
	265	/* GCC 2.95 has explicit, what about earlier versions? */
	266	#define HAVE_EXPLICIT
	267	#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x0520)
	268	/* BC++ 4.52 doesn't support explicit, CBuilder 1 does */
	269	#define HAVE_EXPLICIT
	270	#elif defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
	271	/* Metrowerks CW6 or higher has explicit */
	272	#define HAVE_EXPLICIT
	273	#elif defined(__DIGITALMARS__)
	274	#define HAVE_EXPLICIT
	275	#endif
	276	#endif /* !HAVE_EXPLICIT */
	277
	278	#ifdef HAVE_EXPLICIT
	279	#define wxEXPLICIT explicit
	280	#else /* !HAVE_EXPLICIT */
	281	#define wxEXPLICIT
	282	#endif /* HAVE_EXPLICIT/!HAVE_EXPLICIT */
	283
	284	/* check for static/const_cast<>() (we don't use the other ones for now) */
	285	#ifndef HAVE_CXX_CASTS
	286	#if defined(__VISUALC__) && (__VISUALC__ >= 1100)
	287	/* VC++ 6.0 and 5.0 have C++ casts (what about earlier versions?) */
	288	#define HAVE_CXX_CASTS
	289	#elif defined(__MINGW32__) \|\| defined(__CYGWIN32__)
	290	#if wxCHECK_GCC_VERSION(2, 95)
	291	/* GCC 2.95 has C++ casts, what about earlier versions? */
	292	#define HAVE_CXX_CASTS
	293	#endif
	294	#endif
	295	#endif /* !HAVE_CXX_CASTS */
	296
	297	#ifdef HAVE_CXX_CASTS
	298	#ifndef HAVE_CONST_CAST
	299	#define HAVE_CONST_CAST
	300	#endif
	301	#ifndef HAVE_REINTERPRET_CAST
	302	#define HAVE_REINTERPRET_CAST
	303	#endif
	304	#ifndef HAVE_STATIC_CAST
	305	#define HAVE_STATIC_CAST
	306	#endif
	307	#ifndef HAVE_DYNAMIC_CAST
	308	#define HAVE_DYNAMIC_CAST
	309	#endif
	310	#endif /* HAVE_CXX_CASTS */
	311
	312	#ifdef HAVE_STATIC_CAST
	313	#define wx_static_cast(t, x) static_cast<t>(x)
	314	#else
	315	#define wx_static_cast(t, x) ((t)(x))
	316	#endif
	317
	318	#ifdef HAVE_CONST_CAST
	319	#define wx_const_cast(t, x) const_cast<t>(x)
	320	#else
	321	#define wx_const_cast(t, x) ((t)(x))
	322	#endif
	323
	324	#ifdef HAVE_REINTERPRET_CAST
	325	#define wx_reinterpret_cast(t, x) reinterpret_cast<t>(x)
	326	#else
	327	#define wx_reinterpret_cast(t, x) ((t)(x))
	328	#endif
	329
	330	/*
	331	This one is a wx invention: like static cast but used when we intentionally
	332	truncate from a larger to smaller type, static_cast<> can't be used for it
	333	as it results in warnings when using some compilers (SGI mipspro for example)
	334	*/
	335	#if defined(__INTELC__) && defined(__cplusplus)
	336	template <typename T, typename X>
	337	inline T wx_truncate_cast_impl(X x)
	338	{
	339	#pragma warning(push)
	340	/* implicit conversion of a 64-bit integral type to a smaller integral type */
	341	#pragma warning(disable: 1682)
	342	/* conversion from "X" to "T" may lose significant bits */
	343	#pragma warning(disable: 810)
	344
	345	return x;
	346
	347	#pragma warning(pop)
	348	}
	349
	350	#define wx_truncate_cast(t, x) wx_truncate_cast_impl<t>(x)
	351
	352	#elif defined(__cplusplus) && defined(__VISUALC__) && __VISUALC__ >= 1310
	353	template <typename T, typename X>
	354	inline T wx_truncate_cast_impl(X x)
	355	{
	356	#pragma warning(push)
	357	/* conversion from 'X' to 'T', possible loss of data */
	358	#pragma warning(disable: 4267)
	359
	360	return x;
	361
	362	#pragma warning(pop)
	363	}
	364
	365	#define wx_truncate_cast(t, x) wx_truncate_cast_impl<t>(x)
	366	#else
	367	#define wx_truncate_cast(t, x) ((t)(x))
	368	#endif
	369
	370	/* for consistency with wxStatic/DynamicCast defined in wx/object.h */
	371	#define wxConstCast(obj, className) wx_const_cast(className *, obj)
	372
	373	#ifndef HAVE_STD_WSTRING
	374	#if defined(__VISUALC__) && (__VISUALC__ >= 1100)
	375	/* VC++ 6.0 and 5.0 have std::wstring (what about earlier versions?) */
	376	#define HAVE_STD_WSTRING
	377	#elif ( defined(__MINGW32__) \|\| defined(__CYGWIN32__) ) \
	378	&& wxCHECK_GCC_VERSION(3, 1)
	379	/* GCC 3.1 has std::wstring; 3.0 never was in MinGW, 2.95 hasn't it */
	380	#define HAVE_STD_WSTRING
	381	#endif
	382	#endif
	383
	384	#ifndef HAVE_STD_STRING_COMPARE
	385	#if defined(__VISUALC__) && (__VISUALC__ >= 1100)
	386	/* VC++ 6.0 and 5.0 have std::string::compare */
	387	/* (what about earlier versions?) */
	388	#define HAVE_STD_STRING_COMPARE
	389	#elif ( defined(__MINGW32__) \|\| defined(__CYGWIN32__) ) \
	390	&& wxCHECK_GCC_VERSION(3, 1)
	391	/* GCC 3.1 has std::string::compare; */
	392	/* 3.0 never was in MinGW, 2.95 hasn't it */
	393	#define HAVE_STD_STRING_COMPARE
	394	#endif
	395	#endif
	396
	397	/* provide replacement for C99 va_copy() if the compiler doesn't have it */
	398
	399	/* could be already defined by configure or the user */
	400	#ifndef wxVaCopy
	401	/* if va_copy is a macro or configure detected that we have it, use it */
	402	#if defined(va_copy) \|\| defined(HAVE_VA_COPY)
	403	#define wxVaCopy va_copy
	404	#else /* no va_copy, try to provide a replacement */
	405	/*
	406	configure tries to determine whether va_list is an array or struct
	407	type, but it may not be used under Windows, so deal with a few
	408	special cases.
	409	*/
	410
	411	#ifdef __WATCOMC__
	412	/* Watcom uses array type for va_list except for PPC and Alpha */
	413	#if !defined(__PPC__) && !defined(__AXP__)
	414	#define VA_LIST_IS_ARRAY
	415	#endif
	416	#endif /* __WATCOMC__ */
	417
	418	#if defined(__PPC__) && (defined(_CALL_SYSV) \|\| defined (_WIN32))
	419	/*
	420	PPC using SysV ABI and NT/PPC are special in that they use an
	421	extra level of indirection.
	422	*/
	423	#define VA_LIST_IS_POINTER
	424	#endif /* SysV or Win32 on __PPC__ */
	425
	426	/*
	427	note that we use memmove(), not memcpy(), in case anybody tries
	428	to do wxVaCopy(ap, ap)
	429	*/
	430	#if defined(VA_LIST_IS_POINTER)
	431	#define wxVaCopy(d, s) memmove((d), (s), sizeof(va_list))
	432	#elif defined(VA_LIST_IS_ARRAY)
	433	#define wxVaCopy(d, s) memmove((d), (s), sizeof(va_list))
	434	#else /* we can only hope that va_lists are simple lvalues */
	435	#define wxVaCopy(d, s) ((d) = (s))
	436	#endif
	437	#endif /* va_copy/!va_copy */
	438	#endif /* wxVaCopy */
	439
	440
	441	/* ---------------------------------------------------------------------------- */
	442	/* portable calling conventions macros */
	443	/* ---------------------------------------------------------------------------- */
	444
	445	/* stdcall is used for all functions called by Windows under Windows */
	446	#if defined(__WINDOWS__)
	447	#if defined(__GNUWIN32__)
	448	#define wxSTDCALL __attribute__((stdcall))
	449	#else
	450	/* both VC++ and Borland understand this */
	451	#define wxSTDCALL _stdcall
	452	#endif
	453
	454	#else /* Win */
	455	/* no such stupidness under Unix */
	456	#define wxSTDCALL
	457	#endif /* platform */
	458
	459	/* LINKAGEMODE mode is empty for everyting except OS/2 */
	460	#ifndef LINKAGEMODE
	461	#define LINKAGEMODE
	462	#endif /* LINKAGEMODE */
	463
	464	/* wxCALLBACK should be used for the functions which are called back by */
	465	/* Windows (such as compare function for wxListCtrl) */
	466	#if defined(__WIN32__) && !defined(__WXMICROWIN__)
	467	#define wxCALLBACK wxSTDCALL
	468	#else
	469	/* no stdcall under Unix nor Win16 */
	470	#define wxCALLBACK
	471	#endif /* platform */
	472
	473	/* generic calling convention for the extern "C" functions */
	474
	475	#if defined(__VISUALC__)
	476	#define wxC_CALLING_CONV _cdecl
	477	#elif defined(__VISAGECPP__)
	478	#define wxC_CALLING_CONV _Optlink
	479	#else /* !Visual C++ */
	480	#define wxC_CALLING_CONV
	481	#endif /* compiler */
	482
	483	/* callling convention for the qsort(3) callback */
	484	#define wxCMPFUNC_CONV wxC_CALLING_CONV
	485
	486	/* compatibility :-( */
	487	#define CMPFUNC_CONV wxCMPFUNC_CONV
	488
	489	/* DLL import/export declarations */
	490	#include "wx/dlimpexp.h"
	491
	492	/* ---------------------------------------------------------------------------- */
	493	/* Very common macros */
	494	/* ---------------------------------------------------------------------------- */
	495
	496	/* Printf-like attribute definitions to obtain warnings with GNU C/C++ */
	497	#if defined(__GNUC__) && !wxUSE_UNICODE
	498	# ifndef ATTRIBUTE_PRINTF
	499	# define ATTRIBUTE_PRINTF(m, n) __attribute__ ((__format__ (__printf__, m, n)))
	500	# define ATTRIBUTE_PRINTF_1 ATTRIBUTE_PRINTF(1, 2)
	501	# define ATTRIBUTE_PRINTF_2 ATTRIBUTE_PRINTF(2, 3)
	502	# define ATTRIBUTE_PRINTF_3 ATTRIBUTE_PRINTF(3, 4)
	503	# define ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF(4, 5)
	504	# define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
	505	# endif /* ATTRIBUTE_PRINTF */
	506	#else
	507	# ifndef ATTRIBUTE_PRINTF
	508	# define ATTRIBUTE_PRINTF
	509	# define ATTRIBUTE_PRINTF_1
	510	# define ATTRIBUTE_PRINTF_2
	511	# define ATTRIBUTE_PRINTF_3
	512	# define ATTRIBUTE_PRINTF_4
	513	# define ATTRIBUTE_PRINTF_5
	514	# endif /* ATTRIBUTE_PRINTF */
	515	#endif
	516
	517	/* Macro to issue warning when using deprecated functions with gcc3 or MSVC7: */
	518	#if wxCHECK_GCC_VERSION(3, 1)
	519	#define wxDEPRECATED(x) x __attribute__ ((deprecated))
	520	#elif defined(__VISUALC__) && (__VISUALC__ >= 1300)
	521	#define wxDEPRECATED(x) __declspec(deprecated) x
	522	#else
	523	#define wxDEPRECATED(x) x
	524	#endif
	525
	526	/* everybody gets the assert and other debug macros */
	527	#include "wx/debug.h"
	528
	529	/* NULL declaration: it must be defined as 0 for C++ programs (in particular, */
	530	/* it must not be defined as "(void )0" which is standard for C but completely /
	531	/* breaks C++ code) */
	532	#ifndef __HANDHELDPC__
	533	#include <stddef.h>
	534	#endif
	535
	536	/* delete pointer if it is not NULL and NULL it afterwards */
	537	/* (checking that it's !NULL before passing it to delete is just a */
	538	/* a question of style, because delete will do it itself anyhow, but it might */
	539	/* be considered as an error by some overzealous debugging implementations of */
	540	/* the library, so we do it ourselves) */
	541	#define wxDELETE(p) if ( (p) != NULL ) { delete p; p = NULL; }
	542
	543	/* delete an array and NULL it (see comments above) */
	544	#define wxDELETEA(p) if ( (p) ) { delete [] (p); p = NULL; }
	545
	546	/* size of statically declared array */
	547	#define WXSIZEOF(array) (sizeof(array)/sizeof(array[0]))
	548
	549	/* symbolic constant used by all Find()-like functions returning positive */
	550	/* integer on success as failure indicator */
	551	#define wxNOT_FOUND (-1)
	552
	553	/* ---------------------------------------------------------------------------- */
	554	/* macros to avoid compiler warnings */
	555	/* ---------------------------------------------------------------------------- */
	556
	557	/* Macro to cut down on compiler warnings. */
	558	#if 1 /* there should be no more any compilers needing the "#else" version */
	559	#define WXUNUSED(identifier) /* identifier */
	560	#else /* stupid, broken compiler */
	561	#define WXUNUSED(identifier) identifier
	562	#endif
	563
	564	/* some arguments are only used in debug mode, but unused in release one */
	565	#ifdef __WXDEBUG__
	566	#define WXUNUSED_UNLESS_DEBUG(param) param
	567	#else
	568	#define WXUNUSED_UNLESS_DEBUG(param) WXUNUSED(param)
	569	#endif
	570
	571	/* some arguments are not used in unicode mode */
	572	#if wxUSE_UNICODE
	573	#define WXUNUSED_IN_UNICODE(param) WXUNUSED(param)
	574	#else
	575	#define WXUNUSED_IN_UNICODE(param) param
	576	#endif
	577
	578	/* some arguments are not used in WinCE build */
	579	#ifdef __WXWINCE__
	580	#define WXUNUSED_IN_WINCE(param) WXUNUSED(param)
	581	#else
	582	#define WXUNUSED_IN_WINCE(param) param
	583	#endif
	584
	585	/* unused parameters in non stream builds */
	586	#if wxUSE_STREAMS
	587	#define WXUNUSED_UNLESS_STREAMS(param) param
	588	#else
	589	#define WXUNUSED_UNLESS_STREAMS(param) WXUNUSED(param)
	590	#endif
	591
	592	/* some compilers give warning about a possibly unused variable if it is */
	593	/* initialized in both branches of if/else and shut up if it is initialized */
	594	/* when declared, but other compilers then give warnings about unused variable */
	595	/* value -- this should satisfy both of them */
	596	#if defined(__VISUALC__)
	597	#define wxDUMMY_INITIALIZE(val) = val
	598	#else
	599	#define wxDUMMY_INITIALIZE(val)
	600	#endif
	601
	602	/* sometimes the value of a variable is really not used, to suppress the */
	603	/* resulting warning you may pass it to this function */
	604	#ifdef __cplusplus
	605	# ifdef __BORLANDC__
	606	# define wxUnusedVar(identifier) identifier
	607	# else
	608	template <class T>
	609	inline void wxUnusedVar(const T& WXUNUSED(t)) { }
	610	# endif
	611	#endif
	612
	613	/* ---------------------------------------------------------------------------- */
	614	/* compiler specific settings */
	615	/* ---------------------------------------------------------------------------- */
	616
	617	/* to allow compiling with warning level 4 under Microsoft Visual C++ some */
	618	/* warnings just must be disabled */
	619	#ifdef __VISUALC__
	620	#pragma warning(disable: 4514) /* unreferenced inline func has been removed */
	621	/*
	622	you might be tempted to disable this one also: triggered by CHECK and FAIL
	623	macros in debug.h, but it's, overall, a rather useful one, so I leave it and
	624	will try to find some way to disable this warning just for CHECK/FAIL. Anyone?
	625	*/
	626	#pragma warning(disable: 4127) /* conditional expression is constant */
	627	#endif /* VC++ */
	628
	629	#if defined(__MWERKS__)
	630	#undef try
	631	#undef except
	632	#undef finally
	633	#define except(x) catch(...)
	634	#endif /* Metrowerks */
	635
	636	#if wxONLY_WATCOM_EARLIER_THAN(1,4)
	637	typedef short mode_t;
	638	#endif
	639
	640	/* where should i put this? we need to make sure of this as it breaks */
	641	/* the <iostream> code. */
	642	#if !wxUSE_IOSTREAMH && defined(__WXDEBUG__)
	643	# ifndef __MWERKS__
	644	/* #undef __WXDEBUG__ */
	645	# ifdef wxUSE_DEBUG_NEW_ALWAYS
	646	# undef wxUSE_DEBUG_NEW_ALWAYS
	647	# define wxUSE_DEBUG_NEW_ALWAYS 0
	648	# endif
	649	# endif
	650	#endif
	651
	652	/* ---------------------------------------------------------------------------- */
	653	/* standard wxWidgets types */
	654	/* ---------------------------------------------------------------------------- */
	655
	656	/* the type for screen and DC coordinates */
	657	typedef int wxCoord;
	658
	659	enum { wxDefaultCoord = -1 };
	660
	661	/* ---------------------------------------------------------------------------- */
	662	/* define fixed length types */
	663	/* ---------------------------------------------------------------------------- */
	664
	665	#if defined(__WXPALMOS__) \|\| defined(__MINGW32__)
	666	#include <sys/types.h>
	667	#endif
	668
	669	/* chars are always one byte (by definition), shorts are always two (in */
	670	/* practice) */
	671
	672	/* 8bit */
	673	#ifndef SIZEOF_CHAR
	674	#define SIZEOF_CHAR 1
	675	#endif
	676	typedef signed char wxInt8;
	677	typedef unsigned char wxUint8;
	678	typedef wxUint8 wxByte;
	679
	680
	681	/* 16bit */
	682	#ifdef SIZEOF_SHORT
	683	#if SIZEOF_SHORT != 2
	684	#error "wxWidgets assumes sizeof(short) == 2, please fix the code"
	685	#endif
	686	#else
	687	#define SIZEOF_SHORT 2
	688	#endif
	689
	690	typedef signed short wxInt16;
	691	typedef unsigned short wxUint16;
	692
	693	typedef wxUint16 wxWord;
	694
	695	/*
	696	things are getting more interesting with ints, longs and pointers
	697
	698	there are several different standard data models described by this table:
	699
	700	+-----------+----------------------------+
	701	\|type\model \| LP64 ILP64 LLP64 ILP32 LP32\|
	702	+-----------+----------------------------+
	703	\|char \| 8 8 8 8 8 \|
	704	\|short \| 16 16 16 16 16 \|
	705	\|int \| 32 64 32 32 16 \|
	706	\|long \| 64 64 32 32 32 \|
	707	\|long long \| 64 \|
	708	\|void * \| 64 64 64 32 32 \|
	709	+-----------+----------------------------+
	710
	711	Win16 used LP32 (but we don't support it any longer), Win32 obviously used
	712	ILP32 and Win64 uses LLP64 (a.k.a. P64)
	713
	714	Under Unix LP64 is the most widely used (the only I've ever seen, in fact)
	715	*/
	716
	717	/* 32bit */
	718	#ifdef __PALMOS__
	719	typedef int wxInt32;
	720	typedef unsigned int wxUint32;
	721	#define SIZEOF_INT 4
	722	#define SIZEOF_LONG 4
	723	#define SIZEOF_WCHAR_T 2
	724	#define SIZEOF_SIZE_T 4
	725	#define wxSIZE_T_IS_UINT
	726	#define SIZEOF_VOID_P 4
	727	#define SIZEOF_SIZE_T 4
	728	#elif defined(__WINDOWS__)
	729	/* Win64 uses LLP64 model and so ints and longs have the same size as in */
	730	/* Win32 */
	731	#if defined(__WIN32__)
	732	typedef int wxInt32;
	733	typedef unsigned int wxUint32;
	734
	735	/* Assume that if SIZEOF_INT is defined that all the other ones except
	736	SIZEOF_SIZE_T, are too. See next #if below. */
	737	#ifndef SIZEOF_INT
	738	#define SIZEOF_INT 4
	739	#define SIZEOF_LONG 4
	740	#define SIZEOF_WCHAR_T 2
	741
	742	/*
	743	under Win64 sizeof(size_t) == 8 and so it is neither unsigned
	744	int nor unsigned long!
	745	*/
	746	#ifdef __WIN64__
	747	#define SIZEOF_SIZE_T 8
	748
	749	#undef wxSIZE_T_IS_UINT
	750	#else /* Win32 */
	751	#define SIZEOF_SIZE_T 4
	752
	753	#define wxSIZE_T_IS_UINT
	754	#endif
	755	#undef wxSIZE_T_IS_ULONG
	756
	757	#ifdef __WIN64__
	758	#define SIZEOF_VOID_P 8
	759	#else /* Win32 */
	760	#define SIZEOF_VOID_P 4
	761	#endif /* Win64/32 */
	762	#endif /* !defined(SIZEOF_INT) */
	763
	764	/*
	765	If Python.h was included first, it defines all of the SIZEOF's above
	766	except for SIZEOF_SIZE_T, so we need to do it here to avoid
	767	triggering the #error in the ssize_t typedefs below...
	768	*/
	769	#ifndef SIZEOF_SIZE_T
	770	#ifdef __WIN64__
	771	#define SIZEOF_SIZE_T 8
	772	#else /* Win32 */
	773	#define SIZEOF_SIZE_T 4
	774	#endif
	775	#endif
	776	#else
	777	#error "Unsupported Windows version"
	778	#endif
	779	#else /* !Windows */
	780	/* SIZEOF_XXX are normally defined by configure */
	781	#ifdef SIZEOF_INT
	782	#if SIZEOF_INT == 8
	783	/* must be ILP64 data model, there is normally a special 32 bit */
	784	/* type in it but we don't know what it is... */
	785	#error "No 32bit int type on this platform"
	786	#elif SIZEOF_INT == 4
	787	typedef int wxInt32;
	788	typedef unsigned int wxUint32;
	789	#elif SIZEOF_INT == 2
	790	/* must be LP32 */
	791	#if SIZEOF_LONG != 4
	792	#error "No 32bit int type on this platform"
	793	#endif
	794
	795	typedef long wxInt32;
	796	typedef unsigned long wxUint32;
	797	#else
	798	/* wxWidgets is not ready for 128bit systems yet... */
	799	#error "Unknown sizeof(int) value, what are you compiling for?"
	800	#endif
	801	#else /* !defined(SIZEOF_INT) */
	802	/* assume default 32bit machine -- what else can we do? */
	803	wxCOMPILE_TIME_ASSERT( sizeof(int) == 4, IntMustBeExactly4Bytes);
	804	wxCOMPILE_TIME_ASSERT( sizeof(size_t) == 4, SizeTMustBeExactly4Bytes);
	805	wxCOMPILE_TIME_ASSERT( sizeof(void *) == 4, PtrMustBeExactly4Bytes);
	806
	807	#define SIZEOF_INT 4
	808	#define SIZEOF_SIZE_T 4
	809	#define SIZEOF_VOID_P 4
	810
	811	typedef int wxInt32;
	812	typedef unsigned int wxUint32;
	813
	814	#if defined(__MACH__) && !defined(SIZEOF_WCHAR_T)
	815	#define SIZEOF_WCHAR_T 4
	816	#endif
	817	#if wxUSE_WCHAR_T && !defined(SIZEOF_WCHAR_T)
	818	/* also assume that sizeof(wchar_t) == 2 (under Unix the most */
	819	/* common case is 4 but there configure would have defined */
	820	/* SIZEOF_WCHAR_T for us) */
	821	/* the most common case */
	822	wxCOMPILE_TIME_ASSERT( sizeof(wchar_t) == 2,
	823	Wchar_tMustBeExactly2Bytes);
	824
	825	#define SIZEOF_WCHAR_T 2
	826	#endif /* wxUSE_WCHAR_T */
	827	#endif
	828	#endif /* Win/!Win */
	829
	830	typedef wxUint32 wxDword;
	831
	832	/*
	833	Define an integral type big enough to contain all of long, size_t and void *.
	834	*/
	835	#if SIZEOF_LONG >= SIZEOF_VOID_P && SIZEOF_LONG >= SIZEOF_SIZE_T
	836	/* normal case */
	837	typedef unsigned long wxUIntPtr;
	838	#elif SIZEOF_SIZE_T >= SIZEOF_VOID_P
	839	/* Win64 case */
	840	typedef size_t wxUIntPtr;
	841	#else
	842	/*
	843	This should never happen for the current architectures but if you're
	844	using one where it does, please contact wx-dev@lists.wxwidgets.org.
	845	*/
	846	#error "Pointers can't be stored inside integer types."
	847	#endif
	848
	849	#ifdef __cplusplus
	850	/* And also define a couple of simple functions to cast pointer to/from it. */
	851	inline wxUIntPtr wxPtrToUInt(const void *p)
	852	{
	853	/*
	854	VC++ 7.1 gives warnings about casts such as below even when they're
	855	explicit with /Wp64 option, suppress them as we really know what we're
	856	doing here. Same thing with icc with -Wall.
	857	*/
	858	#ifdef __VISUALC__
	859	#if __VISUALC__ >= 1200
	860	#pragma warning(push)
	861	#endif
	862	/* pointer truncation from '' to '' */
	863	#pragma warning(disable: 4311)
	864	#elif defined(__INTELC__)
	865	#pragma warning(push)
	866	/* conversion from pointer to same-sized integral type */
	867	#pragma warning(disable: 1684)
	868	#endif
	869
	870	return wx_reinterpret_cast(wxUIntPtr, p);
	871
	872	#if (defined(__VISUALC__) && __VISUALC__ >= 1200) \|\| defined(__INTELC__)
	873	#pragma warning(pop)
	874	#endif
	875	}
	876
	877	inline void *wxUIntToPtr(wxUIntPtr p)
	878	{
	879	#ifdef __VISUALC__
	880	#if __VISUALC__ >= 1200
	881	#pragma warning(push)
	882	#endif
	883	/* conversion to type of greater size */
	884	#pragma warning(disable: 4312)
	885	#elif defined(__INTELC__)
	886	#pragma warning(push)
	887	/* invalid type conversion: "wxUIntPtr={unsigned long}" to "void " /
	888	#pragma warning(disable: 171)
	889	#endif
	890
	891	return wx_reinterpret_cast(void *, p);
	892
	893	#if (defined(__VISUALC__) && __VISUALC__ >= 1200) \|\| defined(__INTELC__)
	894	#pragma warning(pop)
	895	#endif
	896	}
	897	#endif /__cplusplus/
	898
	899
	900	/* 64 bit */
	901
	902	/* NB: we #define and not typedef wxLongLong_t because we use "#ifdef */
	903	/* wxLongLong_t" in wx/longlong.h */
	904
	905	/* wxULongLong_t is set later (usually to unsigned wxLongLong_t) */
	906
	907	/* to avoid compilation problems on 64bit machines with ambiguous method calls */
	908	/* we will need to define this */
	909	#undef wxLongLongIsLong
	910
	911	/* first check for generic cases which are long on 64bit machine and "long */
	912	/* long", then check for specific compilers */
	913	#if defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
	914	#define wxLongLong_t long
	915	#define wxLongLongSuffix l
	916	#define wxLongLongFmtSpec _T("l")
	917	#define wxLongLongIsLong
	918	#elif defined(__WXPALMOS__)
	919	#define wxLongLong_t int64_t
	920	#define wxLongLongSuffix ll
	921	#define wxLongLongFmtSpec _T("ll")
	922	#elif (defined(__VISUALC__) && defined(__WIN32__))
	923	#define wxLongLong_t __int64
	924	#define wxLongLongSuffix i64
	925	#define wxLongLongFmtSpec _T("I64")
	926	#elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
	927	#define wxLongLong_t __int64
	928	#define wxLongLongSuffix i64
	929	#define wxLongLongFmtSpec _T("L")
	930	#elif (defined(__WATCOMC__) && (defined(__WIN32__) \|\| defined(__DOS__) \|\| defined(__OS2__)))
	931	#define wxLongLong_t __int64
	932	#define wxLongLongSuffix i64
	933	#define wxLongLongFmtSpec _T("L")
	934	#elif defined(__DIGITALMARS__)
	935	#define wxLongLong_t __int64
	936	#define wxLongLongSuffix LL
	937	#define wxLongLongFmtSpec _T("ll")
	938	#elif defined(__MINGW32__)
	939	#define wxLongLong_t long long
	940	#define wxLongLongSuffix ll
	941	#define wxLongLongFmtSpec _T("I64")
	942	#elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8) \|\| \
	943	defined(__GNUC__) \|\| \
	944	defined(__CYGWIN__) \|\| \
	945	defined(__WXMICROWIN__) \|\| \
	946	(defined(__DJGPP__) && __DJGPP__ >= 2)
	947	#define wxLongLong_t long long
	948	#define wxLongLongSuffix ll
	949	#define wxLongLongFmtSpec _T("ll")
	950	#elif defined(__MWERKS__)
	951	#if __option(longlong)
	952	#define wxLongLong_t long long
	953	#define wxLongLongSuffix ll
	954	#define wxLongLongFmtSpec _T("ll")
	955	#else
	956	#error "The 64 bit integer support in CodeWarrior has been disabled."
	957	#error "See the documentation on the 'longlong' pragma."
	958	#endif
	959	#elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
	960	#define wxLongLong_t long long
	961	#endif
	962
	963
	964	#ifdef wxLongLong_t
	965
	966	#ifdef __WXPALMOS__
	967	#define wxULongLong_t uint64_t
	968	#else
	969	#define wxULongLong_t unsigned wxLongLong_t
	970	#endif
	971
	972	/* these macros allow to define 64 bit constants in a portable way */
	973	#define wxLL(x) wxCONCAT(x, wxLongLongSuffix)
	974	#define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix))
	975
	976	typedef wxLongLong_t wxInt64;
	977	typedef wxULongLong_t wxUint64;
	978
	979	#define wxHAS_INT64 1
	980
	981	#elif wxUSE_LONGLONG
	982	/* these macros allow to define 64 bit constants in a portable way */
	983	#define wxLL(x) wxLongLong(x)
	984	#define wxULL(x) wxULongLong(x)
	985
	986	#define wxInt64 wxLongLong
	987	#define wxUint64 wxULongLong
	988
	989	#define wxHAS_INT64 1
	990
	991	#else /* !wxUSE_LONGLONG */
	992
	993	#define wxHAS_INT64 0
	994
	995	#endif
	996
	997
	998	/* Make sure ssize_t is defined (a signed type the same size as size_t) */
	999	/* HAVE_SSIZE_T should be defined for compiliers that already have it */
	1000	#ifdef __MINGW32__
	1001	#if defined(_SSIZE_T_) && !defined(HAVE_SSIZE_T)
	1002	#define HAVE_SSIZE_T
	1003	#endif
	1004	#endif
	1005	#if defined(__PALMOS__) && !defined(HAVE_SSIZE_T)
	1006	#define HAVE_SSIZE_T
	1007	#endif
	1008	#if wxCHECK_WATCOM_VERSION(1,4)
	1009	#define HAVE_SSIZE_T
	1010	#endif
	1011	#ifndef HAVE_SSIZE_T
	1012	#if SIZEOF_SIZE_T == 4
	1013	typedef wxInt32 ssize_t;
	1014	#elif SIZEOF_SIZE_T == 8
	1015	typedef wxInt64 ssize_t;
	1016	#else
	1017	#error "error defining ssize_t, size_t is not 4 or 8 bytes"
	1018	#endif
	1019	#endif
	1020
	1021
	1022	/* base floating point types */
	1023	/* wxFloat32: 32 bit IEEE float ( 1 sign, 8 exponent bits, 23 fraction bits */
	1024	/* wxFloat64: 64 bit IEEE float ( 1 sign, 11 exponent bits, 52 fraction bits */
	1025	/* wxDouble: native fastest representation that has at least wxFloat64 */
	1026	/* precision, so use the IEEE types for storage, and this for */
	1027	/* calculations */
	1028
	1029	typedef float wxFloat32;
	1030	#if (defined( __WXMAC__ ) \|\| defined(__WXCOCOA__)) && defined (__MWERKS__)
	1031	typedef short double wxFloat64;
	1032	#else
	1033	typedef double wxFloat64;
	1034	#endif
	1035
	1036	#if defined( __WXMAC__ ) && !defined( __POWERPC__ )
	1037	typedef long double wxDouble;
	1038	#else
	1039	typedef double wxDouble;
	1040	#endif
	1041
	1042	/*
	1043	Some (non standard) compilers typedef wchar_t as an existing type instead
	1044	of treating it as a real fundamental type, set wxWCHAR_T_IS_REAL_TYPE to 0
	1045	for them and to 1 for all the others.
	1046	*/
	1047	#if wxUSE_WCHAR_T
	1048	/*
	1049	VC++ typedefs wchar_t as unsigned short by default, that is unless
	1050	/Za or /Zc:wchar_t option is used in which case _WCHAR_T_DEFINED is
	1051	defined.
	1052	*/
	1053	# if defined(__VISUALC__) && !defined(_NATIVE_WCHAR_T_DEFINED)
	1054	# define wxWCHAR_T_IS_REAL_TYPE 0
	1055	# else /* compiler having standard-conforming wchar_t */
	1056	# define wxWCHAR_T_IS_REAL_TYPE 1
	1057	# endif
	1058	#endif /* wxUSE_WCHAR_T */
	1059
	1060	/* ---------------------------------------------------------------------------- */
	1061	/* byte ordering related definition and macros */
	1062	/* ---------------------------------------------------------------------------- */
	1063
	1064	/* byte sex */
	1065
	1066	#define wxBIG_ENDIAN 4321
	1067	#define wxLITTLE_ENDIAN 1234
	1068	#define wxPDP_ENDIAN 3412
	1069
	1070	#ifdef WORDS_BIGENDIAN
	1071	#define wxBYTE_ORDER wxBIG_ENDIAN
	1072	#else
	1073	#define wxBYTE_ORDER wxLITTLE_ENDIAN
	1074	#endif
	1075
	1076	/* byte swapping */
	1077
	1078	#if defined (__MWERKS__) && ( (__MWERKS__ < 0x0900) \|\| macintosh )
	1079	/* assembler versions for these */
	1080	#ifdef __POWERPC__
	1081	inline wxUint16 wxUINT16_SWAP_ALWAYS( wxUint16 i )
	1082	{return (__lhbrx( &i , 0 ) );}
	1083	inline wxInt16 wxINT16_SWAP_ALWAYS( wxInt16 i )
	1084	{return (__lhbrx( &i , 0 ) );}
	1085	inline wxUint32 wxUINT32_SWAP_ALWAYS( wxUint32 i )
	1086	{return (__lwbrx( &i , 0 ) );}
	1087	inline wxInt32 wxINT32_SWAP_ALWAYS( wxInt32 i )
	1088	{return (__lwbrx( &i , 0 ) );}
	1089	#else
	1090	#pragma parameter __D0 wxUINT16_SWAP_ALWAYS(__D0)
	1091	pascal wxUint16 wxUINT16_SWAP_ALWAYS(wxUint16 value)
	1092	= { 0xE158 };
	1093
	1094	#pragma parameter __D0 wxINT16_SWAP_ALWAYS(__D0)
	1095	pascal wxInt16 wxINT16_SWAP_ALWAYS(wxInt16 value)
	1096	= { 0xE158 };
	1097
	1098	#pragma parameter __D0 wxUINT32_SWAP_ALWAYS (__D0)
	1099	pascal wxUint32 wxUINT32_SWAP_ALWAYS(wxUint32 value)
	1100	= { 0xE158, 0x4840, 0xE158 };
	1101
	1102	#pragma parameter __D0 wxINT32_SWAP_ALWAYS (__D0)
	1103	pascal wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value)
	1104	= { 0xE158, 0x4840, 0xE158 };
	1105
	1106	#endif
	1107	#else /* !MWERKS */
	1108	#define wxUINT16_SWAP_ALWAYS(val) \
	1109	((wxUint16) ( \
	1110	(((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) \| \
	1111	(((wxUint16) (val) & (wxUint16) 0xff00U) >> 8)))
	1112
	1113	#define wxINT16_SWAP_ALWAYS(val) \
	1114	((wxInt16) ( \
	1115	(((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) \| \
	1116	(((wxUint16) (val) & (wxUint16) 0xff00U) >> 8)))
	1117
	1118	#define wxUINT32_SWAP_ALWAYS(val) \
	1119	((wxUint32) ( \
	1120	(((wxUint32) (val) & (wxUint32) 0x000000ffU) << 24) \| \
	1121	(((wxUint32) (val) & (wxUint32) 0x0000ff00U) << 8) \| \
	1122	(((wxUint32) (val) & (wxUint32) 0x00ff0000U) >> 8) \| \
	1123	(((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
	1124
	1125	#define wxINT32_SWAP_ALWAYS(val) \
	1126	((wxInt32) ( \
	1127	(((wxUint32) (val) & (wxUint32) 0x000000ffU) << 24) \| \
	1128	(((wxUint32) (val) & (wxUint32) 0x0000ff00U) << 8) \| \
	1129	(((wxUint32) (val) & (wxUint32) 0x00ff0000U) >> 8) \| \
	1130	(((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
	1131	#endif
	1132	/* machine specific byte swapping */
	1133
	1134	#ifdef wxLongLong_t
	1135	#define wxUINT64_SWAP_ALWAYS(val) \
	1136	((wxUint64) ( \
	1137	(((wxUint64) (val) & (wxUint64) wxULL(0x00000000000000ff)) << 56) \| \
	1138	(((wxUint64) (val) & (wxUint64) wxULL(0x000000000000ff00)) << 40) \| \
	1139	(((wxUint64) (val) & (wxUint64) wxULL(0x0000000000ff0000)) << 24) \| \
	1140	(((wxUint64) (val) & (wxUint64) wxULL(0x00000000ff000000)) << 8) \| \
	1141	(((wxUint64) (val) & (wxUint64) wxULL(0x000000ff00000000)) >> 8) \| \
	1142	(((wxUint64) (val) & (wxUint64) wxULL(0x0000ff0000000000)) >> 24) \| \
	1143	(((wxUint64) (val) & (wxUint64) wxULL(0x00ff000000000000)) >> 40) \| \
	1144	(((wxUint64) (val) & (wxUint64) wxULL(0xff00000000000000)) >> 56)))
	1145
	1146	#define wxINT64_SWAP_ALWAYS(val) \
	1147	((wxInt64) ( \
	1148	(((wxUint64) (val) & (wxUint64) wxULL(0x00000000000000ff)) << 56) \| \
	1149	(((wxUint64) (val) & (wxUint64) wxULL(0x000000000000ff00)) << 40) \| \
	1150	(((wxUint64) (val) & (wxUint64) wxULL(0x0000000000ff0000)) << 24) \| \
	1151	(((wxUint64) (val) & (wxUint64) wxULL(0x00000000ff000000)) << 8) \| \
	1152	(((wxUint64) (val) & (wxUint64) wxULL(0x000000ff00000000)) >> 8) \| \
	1153	(((wxUint64) (val) & (wxUint64) wxULL(0x0000ff0000000000)) >> 24) \| \
	1154	(((wxUint64) (val) & (wxUint64) wxULL(0x00ff000000000000)) >> 40) \| \
	1155	(((wxUint64) (val) & (wxUint64) wxULL(0xff00000000000000)) >> 56)))
	1156	#elif wxUSE_LONGLONG /* !wxLongLong_t */
	1157	#define wxUINT64_SWAP_ALWAYS(val) \
	1158	((wxUint64) ( \
	1159	((wxULongLong(val) & wxULongLong(0L, 0x000000ffU)) << 56) \| \
	1160	((wxULongLong(val) & wxULongLong(0L, 0x0000ff00U)) << 40) \| \
	1161	((wxULongLong(val) & wxULongLong(0L, 0x00ff0000U)) << 24) \| \
	1162	((wxULongLong(val) & wxULongLong(0L, 0xff000000U)) << 8) \| \
	1163	((wxULongLong(val) & wxULongLong(0x000000ffL, 0U)) >> 8) \| \
	1164	((wxULongLong(val) & wxULongLong(0x0000ff00L, 0U)) >> 24) \| \
	1165	((wxULongLong(val) & wxULongLong(0x00ff0000L, 0U)) >> 40) \| \
	1166	((wxULongLong(val) & wxULongLong(0xff000000L, 0U)) >> 56)))
	1167
	1168	#define wxINT64_SWAP_ALWAYS(val) \
	1169	((wxInt64) ( \
	1170	((wxLongLong(val) & wxLongLong(0L, 0x000000ffU)) << 56) \| \
	1171	((wxLongLong(val) & wxLongLong(0L, 0x0000ff00U)) << 40) \| \
	1172	((wxLongLong(val) & wxLongLong(0L, 0x00ff0000U)) << 24) \| \
	1173	((wxLongLong(val) & wxLongLong(0L, 0xff000000U)) << 8) \| \
	1174	((wxLongLong(val) & wxLongLong(0x000000ffL, 0U)) >> 8) \| \
	1175	((wxLongLong(val) & wxLongLong(0x0000ff00L, 0U)) >> 24) \| \
	1176	((wxLongLong(val) & wxLongLong(0x00ff0000L, 0U)) >> 40) \| \
	1177	((wxLongLong(val) & wxLongLong(0xff000000L, 0U)) >> 56)))
	1178	#endif /* wxLongLong_t/!wxLongLong_t */
	1179
	1180	#ifdef WORDS_BIGENDIAN
	1181	#define wxUINT16_SWAP_ON_BE(val) wxUINT16_SWAP_ALWAYS(val)
	1182	#define wxINT16_SWAP_ON_BE(val) wxINT16_SWAP_ALWAYS(val)
	1183	#define wxUINT16_SWAP_ON_LE(val) (val)
	1184	#define wxINT16_SWAP_ON_LE(val) (val)
	1185	#define wxUINT32_SWAP_ON_BE(val) wxUINT32_SWAP_ALWAYS(val)
	1186	#define wxINT32_SWAP_ON_BE(val) wxINT32_SWAP_ALWAYS(val)
	1187	#define wxUINT32_SWAP_ON_LE(val) (val)
	1188	#define wxINT32_SWAP_ON_LE(val) (val)
	1189	#if wxHAS_INT64
	1190	#define wxUINT64_SWAP_ON_BE(val) wxUINT64_SWAP_ALWAYS(val)
	1191	#define wxUINT64_SWAP_ON_LE(val) (val)
	1192	#endif
	1193	#else
	1194	#define wxUINT16_SWAP_ON_LE(val) wxUINT16_SWAP_ALWAYS(val)
	1195	#define wxINT16_SWAP_ON_LE(val) wxINT16_SWAP_ALWAYS(val)
	1196	#define wxUINT16_SWAP_ON_BE(val) (val)
	1197	#define wxINT16_SWAP_ON_BE(val) (val)
	1198	#define wxUINT32_SWAP_ON_LE(val) wxUINT32_SWAP_ALWAYS(val)
	1199	#define wxINT32_SWAP_ON_LE(val) wxINT32_SWAP_ALWAYS(val)
	1200	#define wxUINT32_SWAP_ON_BE(val) (val)
	1201	#define wxINT32_SWAP_ON_BE(val) (val)
	1202	#if wxHAS_INT64
	1203	#define wxUINT64_SWAP_ON_LE(val) wxUINT64_SWAP_ALWAYS(val)
	1204	#define wxUINT64_SWAP_ON_BE(val) (val)
	1205	#endif
	1206	#endif
	1207
	1208	/* ---------------------------------------------------------------------------- */
	1209	/* Geometric flags */
	1210	/* ---------------------------------------------------------------------------- */
	1211
	1212	enum wxGeometryCentre
	1213	{
	1214	wxCENTRE = 0x0001,
	1215	wxCENTER = wxCENTRE
	1216	};
	1217
	1218	/* centering into frame rather than screen (obsolete) */
	1219	#define wxCENTER_FRAME 0x0000
	1220	/* centre on screen rather than parent */
	1221	#define wxCENTRE_ON_SCREEN 0x0002
	1222	#define wxCENTER_ON_SCREEN wxCENTRE_ON_SCREEN
	1223
	1224	enum wxOrientation
	1225	{
	1226	/* don't change the values of these elements, they are used elsewhere */
	1227	wxHORIZONTAL = 0x0004,
	1228	wxVERTICAL = 0x0008,
	1229
	1230	wxBOTH = wxVERTICAL \| wxHORIZONTAL
	1231	};
	1232
	1233	enum wxDirection
	1234	{
	1235	wxLEFT = 0x0010,
	1236	wxRIGHT = 0x0020,
	1237	wxUP = 0x0040,
	1238	wxDOWN = 0x0080,
	1239
	1240	wxTOP = wxUP,
	1241	wxBOTTOM = wxDOWN,
	1242
	1243	wxNORTH = wxUP,
	1244	wxSOUTH = wxDOWN,
	1245	wxWEST = wxLEFT,
	1246	wxEAST = wxRIGHT,
	1247
	1248	wxALL = (wxUP \| wxDOWN \| wxRIGHT \| wxLEFT)
	1249	};
	1250
	1251	enum wxAlignment
	1252	{
	1253	wxALIGN_NOT = 0x0000,
	1254	wxALIGN_CENTER_HORIZONTAL = 0x0100,
	1255	wxALIGN_CENTRE_HORIZONTAL = wxALIGN_CENTER_HORIZONTAL,
	1256	wxALIGN_LEFT = wxALIGN_NOT,
	1257	wxALIGN_TOP = wxALIGN_NOT,
	1258	wxALIGN_RIGHT = 0x0200,
	1259	wxALIGN_BOTTOM = 0x0400,
	1260	wxALIGN_CENTER_VERTICAL = 0x0800,
	1261	wxALIGN_CENTRE_VERTICAL = wxALIGN_CENTER_VERTICAL,
	1262
	1263	wxALIGN_CENTER = (wxALIGN_CENTER_HORIZONTAL \| wxALIGN_CENTER_VERTICAL),
	1264	wxALIGN_CENTRE = wxALIGN_CENTER,
	1265
	1266	/* a mask to extract alignment from the combination of flags */
	1267	wxALIGN_MASK = 0x0f00
	1268	};
	1269
	1270	enum wxStretch
	1271	{
	1272	wxSTRETCH_NOT = 0x0000,
	1273	wxSHRINK = 0x1000,
	1274	wxGROW = 0x2000,
	1275	wxEXPAND = wxGROW,
	1276	wxSHAPED = 0x4000,
	1277	wxFIXED_MINSIZE = 0x8000,
	1278	wxTILE = 0xc000,
	1279
	1280	/* for compatibility only, default now, don't use explicitly any more */
	1281	#if WXWIN_COMPATIBILITY_2_4
	1282	wxADJUST_MINSIZE = 0x00100000
	1283	#else
	1284	wxADJUST_MINSIZE = 0
	1285	#endif
	1286	};
	1287
	1288	/* border flags: the values are chosen for backwards compatibility */
	1289	enum wxBorder
	1290	{
	1291	/* this is different from wxBORDER_NONE as by default the controls do have */
	1292	/* border */
	1293	wxBORDER_DEFAULT = 0,
	1294
	1295	wxBORDER_NONE = 0x00200000,
	1296	wxBORDER_STATIC = 0x01000000,
	1297	wxBORDER_SIMPLE = 0x02000000,
	1298	wxBORDER_RAISED = 0x04000000,
	1299	wxBORDER_SUNKEN = 0x08000000,
	1300	wxBORDER_DOUBLE = 0x10000000,
	1301
	1302	/* a mask to extract border style from the combination of flags */
	1303	wxBORDER_MASK = 0x1f200000
	1304	};
	1305
	1306	/* This makes it easier to specify a 'normal' border for a control */
	1307	#if defined(__SMARTPHONE__) \|\| defined(__POCKETPC__)
	1308	#define wxDEFAULT_CONTROL_BORDER wxBORDER_SIMPLE
	1309	#else
	1310	#define wxDEFAULT_CONTROL_BORDER wxBORDER_SUNKEN
	1311	#endif
	1312
	1313	/* ---------------------------------------------------------------------------- */
	1314	/* Window style flags */
	1315	/* ---------------------------------------------------------------------------- */
	1316
	1317	/*
	1318	* Values are chosen so they can be \|'ed in a bit list.
	1319	* Some styles are used across more than one group,
	1320	* so the values mustn't clash with others in the group.
	1321	* Otherwise, numbers can be reused across groups.
	1322	*
	1323	* From version 1.66:
	1324	* Window (cross-group) styles now take up the first half
	1325	* of the flag, and control-specific styles the
	1326	* second half.
	1327	*
	1328	*/
	1329
	1330	/*
	1331	* Window (Frame/dialog/subwindow/panel item) style flags
	1332	*/
	1333	#define wxVSCROLL 0x80000000
	1334	#define wxHSCROLL 0x40000000
	1335	#define wxCAPTION 0x20000000
	1336
	1337	/* New styles (border styles are now in their own enum) */
	1338	#define wxDOUBLE_BORDER wxBORDER_DOUBLE
	1339	#define wxSUNKEN_BORDER wxBORDER_SUNKEN
	1340	#define wxRAISED_BORDER wxBORDER_RAISED
	1341	#define wxBORDER wxBORDER_SIMPLE
	1342	#define wxSIMPLE_BORDER wxBORDER_SIMPLE
	1343	#define wxSTATIC_BORDER wxBORDER_STATIC
	1344	#define wxNO_BORDER wxBORDER_NONE
	1345
	1346	/* wxALWAYS_SHOW_SB: instead of hiding the scrollbar when it is not needed, */
	1347	/* disable it - but still show (see also wxLB_ALWAYS_SB style) */
	1348	/* */
	1349	/* NB: as this style is only supported by wxUniversal and wxMSW so far */
	1350	#define wxALWAYS_SHOW_SB 0x00800000
	1351
	1352	/* Clip children when painting, which reduces flicker in e.g. frames and */
	1353	/* splitter windows, but can't be used in a panel where a static box must be */
	1354	/* 'transparent' (panel paints the background for it) */
	1355	#define wxCLIP_CHILDREN 0x00400000
	1356
	1357	/* Note we're reusing the wxCAPTION style because we won't need captions */
	1358	/* for subwindows/controls */
	1359	#define wxCLIP_SIBLINGS 0x20000000
	1360
	1361	#define wxTRANSPARENT_WINDOW 0x00100000
	1362
	1363	/* Add this style to a panel to get tab traversal working outside of dialogs */
	1364	/* (on by default for wxPanel, wxDialog, wxScrolledWindow) */
	1365	#define wxTAB_TRAVERSAL 0x00080000
	1366
	1367	/* Add this style if the control wants to get all keyboard messages (under */
	1368	/* Windows, it won't normally get the dialog navigation key events) */
	1369	#define wxWANTS_CHARS 0x00040000
	1370
	1371	/* Make window retained (Motif only, see src/generic/scrolwing.cpp)
	1372	* This is non-zero only under wxMotif, to avoid a clash with wxPOPUP_WINDOW
	1373	* on other platforms
	1374	*/
	1375
	1376	#ifdef __WXMOTIF__
	1377	#define wxRETAINED 0x00020000
	1378	#else
	1379	#define wxRETAINED 0x00000000
	1380	#endif
	1381	#define wxBACKINGSTORE wxRETAINED
	1382
	1383	/* set this flag to create a special popup window: it will be always shown on */
	1384	/* top of other windows, will capture the mouse and will be dismissed when the */
	1385	/* mouse is clicked outside of it or if it loses focus in any other way */
	1386	#define wxPOPUP_WINDOW 0x00020000
	1387
	1388	/* force a full repaint when the window is resized (instead of repainting just */
	1389	/* the invalidated area) */
	1390	#define wxFULL_REPAINT_ON_RESIZE 0x00010000
	1391
	1392	/* obsolete: now this is the default behaviour */
	1393	/* */
	1394	/* don't invalidate the whole window (resulting in a PAINT event) when the */
	1395	/* window is resized (currently, makes sense for wxMSW only) */
	1396	#define wxNO_FULL_REPAINT_ON_RESIZE 0
	1397
	1398	/* A mask which can be used to filter (out) all wxWindow-specific styles.
	1399	*/
	1400	#define wxWINDOW_STYLE_MASK \
	1401	(wxVSCROLL\|wxHSCROLL\|wxBORDER_MASK\|wxALWAYS_SHOW_SB\|wxCLIP_CHILDREN\| \
	1402	wxCLIP_SIBLINGS\|wxTRANSPARENT_WINDOW\|wxTAB_TRAVERSAL\|wxWANTS_CHARS\| \
	1403	wxRETAINED\|wxPOPUP_WINDOW\|wxFULL_REPAINT_ON_RESIZE)
	1404
	1405	/*
	1406	* Extra window style flags (use wxWS_EX prefix to make it clear that they
	1407	* should be passed to wxWindow::SetExtraStyle(), not SetWindowStyle())
	1408	*/
	1409
	1410	/* by default, TransferDataTo/FromWindow() only work on direct children of the */
	1411	/* window (compatible behaviour), set this flag to make them recursively */
	1412	/* descend into all subwindows */
	1413	#define wxWS_EX_VALIDATE_RECURSIVELY 0x00000001
	1414
	1415	/* wxCommandEvents and the objects of the derived classes are forwarded to the */
	1416	/* parent window and so on recursively by default. Using this flag for the */
	1417	/* given window allows to block this propagation at this window, i.e. prevent */
	1418	/* the events from being propagated further upwards. The dialogs have this */
	1419	/* flag on by default. */
	1420	#define wxWS_EX_BLOCK_EVENTS 0x00000002
	1421
	1422	/* don't use this window as an implicit parent for the other windows: this must */
	1423	/* be used with transient windows as otherwise there is the risk of creating a */
	1424	/* dialog/frame with this window as a parent which would lead to a crash if the */
	1425	/* parent is destroyed before the child */
	1426	#define wxWS_EX_TRANSIENT 0x00000004
	1427
	1428	/* don't paint the window background, we'll assume it will */
	1429	/* be done by a theming engine. This is not yet used but could */
	1430	/* possibly be made to work in the future, at least on Windows */
	1431	#define wxWS_EX_THEMED_BACKGROUND 0x00000008
	1432
	1433	/* this window should always process idle events */
	1434	#define wxWS_EX_PROCESS_IDLE 0x00000010
	1435
	1436	/* this window should always process UI update events */
	1437	#define wxWS_EX_PROCESS_UI_UPDATES 0x00000020
	1438
	1439	/* Draw the window in a metal theme on Mac */
	1440	#define wxFRAME_EX_METAL 0x00000040
	1441	#define wxDIALOG_EX_METAL 0x00000040
	1442
	1443	/* Use this style to add a context-sensitive help to the window (currently for */
	1444	/* Win32 only and it doesn't work if wxMINIMIZE_BOX or wxMAXIMIZE_BOX are used) */
	1445	#define wxWS_EX_CONTEXTHELP 0x00000080
	1446
	1447	/* synonyms for wxWS_EX_CONTEXTHELP for compatibility */
	1448	#define wxFRAME_EX_CONTEXTHELP wxWS_EX_CONTEXTHELP
	1449	#define wxDIALOG_EX_CONTEXTHELP wxWS_EX_CONTEXTHELP
	1450
	1451	/* Create a window which is attachable to another top level window */
	1452	#define wxFRAME_DRAWER 0x0020
	1453
	1454	/*
	1455	* MDI parent frame style flags
	1456	* Can overlap with some of the above.
	1457	*/
	1458
	1459	#define wxFRAME_NO_WINDOW_MENU 0x0100
	1460
	1461	/*
	1462	* wxMenuBar style flags
	1463	*/
	1464	/* use native docking */
	1465	#define wxMB_DOCKABLE 0x0001
	1466
	1467	/*
	1468	* wxMenu style flags
	1469	*/
	1470	#define wxMENU_TEAROFF 0x0001
	1471
	1472	/*
	1473	* Apply to all panel items
	1474	*/
	1475	#define wxCOLOURED 0x0800
	1476	#define wxFIXED_LENGTH 0x0400
	1477
	1478	/*
	1479	* Styles for wxListBox
	1480	*/
	1481	#define wxLB_SORT 0x0010
	1482	#define wxLB_SINGLE 0x0020
	1483	#define wxLB_MULTIPLE 0x0040
	1484	#define wxLB_EXTENDED 0x0080
	1485	/* wxLB_OWNERDRAW is Windows-only */
	1486	#define wxLB_OWNERDRAW 0x0100
	1487	#define wxLB_NEEDED_SB 0x0200
	1488	#define wxLB_ALWAYS_SB 0x0400
	1489	#define wxLB_HSCROLL wxHSCROLL
	1490	/* always show an entire number of rows */
	1491	#define wxLB_INT_HEIGHT 0x0800
	1492
	1493	#if WXWIN_COMPATIBILITY_2_6
	1494	/* deprecated synonyms */
	1495	#define wxPROCESS_ENTER 0x0400 /* wxTE_PROCESS_ENTER */
	1496	#define wxPASSWORD 0x0800 /* wxTE_PASSWORD */
	1497	#endif
	1498
	1499	/*
	1500	* wxComboBox style flags
	1501	*/
	1502	#define wxCB_SIMPLE 0x0004
	1503	#define wxCB_SORT 0x0008
	1504	#define wxCB_READONLY 0x0010
	1505	#define wxCB_DROPDOWN 0x0020
	1506
	1507	/*
	1508	* wxRadioBox style flags
	1509	*/
	1510	/* should we number the items from left to right or from top to bottom in a 2d */
	1511	/* radiobox? */
	1512	#define wxRA_LEFTTORIGHT 0x0001
	1513	#define wxRA_TOPTOBOTTOM 0x0002
	1514
	1515	/* New, more intuitive names to specify majorDim argument */
	1516	#define wxRA_SPECIFY_COLS wxHORIZONTAL
	1517	#define wxRA_SPECIFY_ROWS wxVERTICAL
	1518
	1519	/* Old names for compatibility */
	1520	#define wxRA_HORIZONTAL wxHORIZONTAL
	1521	#define wxRA_VERTICAL wxVERTICAL
	1522	#define wxRA_USE_CHECKBOX 0x0010 /* alternative native subcontrols (wxPalmOS) */
	1523
	1524	/*
	1525	* wxRadioButton style flag
	1526	*/
	1527	#define wxRB_GROUP 0x0004
	1528	#define wxRB_SINGLE 0x0008
	1529	#define wxRB_USE_CHECKBOX 0x0010 /* alternative native control (wxPalmOS) */
	1530
	1531	/*
	1532	* wxScrollBar flags
	1533	*/
	1534	#define wxSB_HORIZONTAL wxHORIZONTAL
	1535	#define wxSB_VERTICAL wxVERTICAL
	1536
	1537	/*
	1538	* wxSpinButton flags.
	1539	* Note that a wxSpinCtrl is sometimes defined as
	1540	* a wxTextCtrl, and so the flags must be different
	1541	* from wxTextCtrl's.
	1542	*/
	1543	#define wxSP_HORIZONTAL wxHORIZONTAL /* 4 */
	1544	#define wxSP_VERTICAL wxVERTICAL /* 8 */
	1545	#define wxSP_ARROW_KEYS 0x1000
	1546	#define wxSP_WRAP 0x2000
	1547
	1548	/*
	1549	* wxTabCtrl flags
	1550	*/
	1551	#define wxTC_RIGHTJUSTIFY 0x0010
	1552	#define wxTC_FIXEDWIDTH 0x0020
	1553	#define wxTC_TOP 0x0000 /* default */
	1554	#define wxTC_LEFT 0x0020
	1555	#define wxTC_RIGHT 0x0040
	1556	#define wxTC_BOTTOM 0x0080
	1557	#define wxTC_MULTILINE wxNB_MULTILINE
	1558	#define wxTC_OWNERDRAW 0x0200
	1559
	1560	/*
	1561	* wxStatusBar95 flags
	1562	*/
	1563	#define wxST_SIZEGRIP 0x0010
	1564
	1565	/*
	1566	* wxStaticText flags
	1567	*/
	1568	#define wxST_NO_AUTORESIZE 0x0001
	1569	#define wxST_DOTS_MIDDLE 0x0002
	1570	#define wxST_DOTS_END 0x0004
	1571
	1572	/*
	1573	* wxStaticBitmap flags
	1574	*/
	1575	#define wxBI_EXPAND wxEXPAND
	1576
	1577	/*
	1578	* wxStaticLine flags
	1579	*/
	1580	#define wxLI_HORIZONTAL wxHORIZONTAL
	1581	#define wxLI_VERTICAL wxVERTICAL
	1582
	1583
	1584	/*
	1585	* extended dialog specifiers. these values are stored in a different
	1586	* flag and thus do not overlap with other style flags. note that these
	1587	* values do not correspond to the return values of the dialogs (for
	1588	* those values, look at the wxID_XXX defines).
	1589	*/
	1590
	1591	/* wxCENTRE already defined as 0x00000001 */
	1592	#define wxYES 0x00000002
	1593	#define wxOK 0x00000004
	1594	#define wxNO 0x00000008
	1595	#define wxYES_NO (wxYES \| wxNO)
	1596	#define wxCANCEL 0x00000010
	1597
	1598	#define wxYES_DEFAULT 0x00000000 /* has no effect (default) */
	1599	#define wxNO_DEFAULT 0x00000080
	1600
	1601	#define wxICON_EXCLAMATION 0x00000100
	1602	#define wxICON_HAND 0x00000200
	1603	#define wxICON_WARNING wxICON_EXCLAMATION
	1604	#define wxICON_ERROR wxICON_HAND
	1605	#define wxICON_QUESTION 0x00000400
	1606	#define wxICON_INFORMATION 0x00000800
	1607	#define wxICON_STOP wxICON_HAND
	1608	#define wxICON_ASTERISK wxICON_INFORMATION
	1609	#define wxICON_MASK (0x00000100\|0x00000200\|0x00000400\|0x00000800)
	1610
	1611	#define wxFORWARD 0x00001000
	1612	#define wxBACKWARD 0x00002000
	1613	#define wxRESET 0x00004000
	1614	#define wxHELP 0x00008000
	1615	#define wxMORE 0x00010000
	1616	#define wxSETUP 0x00020000
	1617
	1618	/*
	1619	* Background styles. See wxWindow::SetBackgroundStyle
	1620	*/
	1621
	1622	enum wxBackgroundStyle
	1623	{
	1624	wxBG_STYLE_SYSTEM,
	1625	wxBG_STYLE_COLOUR,
	1626	wxBG_STYLE_CUSTOM
	1627	};
	1628
	1629	/* ---------------------------------------------------------------------------- */
	1630	/* standard IDs */
	1631	/* ---------------------------------------------------------------------------- */
	1632
	1633	/* Standard menu IDs */
	1634	enum
	1635	{
	1636	/* no id matches this one when compared to it */
	1637	wxID_NONE = -3,
	1638
	1639	/* id for a separator line in the menu (invalid for normal item) */
	1640	wxID_SEPARATOR = -2,
	1641
	1642	/* any id: means that we don't care about the id, whether when installing
	1643	* an event handler or when creating a new window */
	1644	wxID_ANY = -1,
	1645
	1646
	1647	/* all predefined ids are between wxID_LOWEST and wxID_HIGHEST */
	1648	wxID_LOWEST = 4999,
	1649
	1650	wxID_OPEN,
	1651	wxID_CLOSE,
	1652	wxID_NEW,
	1653	wxID_SAVE,
	1654	wxID_SAVEAS,
	1655	wxID_REVERT,
	1656	wxID_EXIT,
	1657	wxID_UNDO,
	1658	wxID_REDO,
	1659	wxID_HELP,
	1660	wxID_PRINT,
	1661	wxID_PRINT_SETUP,
	1662	wxID_PAGE_SETUP,
	1663	wxID_PREVIEW,
	1664	wxID_ABOUT,
	1665	wxID_HELP_CONTENTS,
	1666	wxID_HELP_INDEX,
	1667	wxID_HELP_SEARCH,
	1668	wxID_HELP_COMMANDS,
	1669	wxID_HELP_PROCEDURES,
	1670	wxID_HELP_CONTEXT,
	1671	wxID_CLOSE_ALL,
	1672	wxID_PREFERENCES,
	1673
	1674	wxID_EDIT = 5030,
	1675	wxID_CUT,
	1676	wxID_COPY,
	1677	wxID_PASTE,
	1678	wxID_CLEAR,
	1679	wxID_FIND,
	1680	wxID_DUPLICATE,
	1681	wxID_SELECTALL,
	1682	wxID_DELETE,
	1683	wxID_REPLACE,
	1684	wxID_REPLACE_ALL,
	1685	wxID_PROPERTIES,
	1686
	1687	wxID_VIEW_DETAILS,
	1688	wxID_VIEW_LARGEICONS,
	1689	wxID_VIEW_SMALLICONS,
	1690	wxID_VIEW_LIST,
	1691	wxID_VIEW_SORTDATE,
	1692	wxID_VIEW_SORTNAME,
	1693	wxID_VIEW_SORTSIZE,
	1694	wxID_VIEW_SORTTYPE,
	1695
	1696	wxID_FILE = 5050,
	1697	wxID_FILE1,
	1698	wxID_FILE2,
	1699	wxID_FILE3,
	1700	wxID_FILE4,
	1701	wxID_FILE5,
	1702	wxID_FILE6,
	1703	wxID_FILE7,
	1704	wxID_FILE8,
	1705	wxID_FILE9,
	1706
	1707	/* Standard button and menu IDs */
	1708	wxID_OK = 5100,
	1709	wxID_CANCEL,
	1710	wxID_APPLY,
	1711	wxID_YES,
	1712	wxID_NO,
	1713	wxID_STATIC,
	1714	wxID_FORWARD,
	1715	wxID_BACKWARD,
	1716	wxID_DEFAULT,
	1717	wxID_MORE,
	1718	wxID_SETUP,
	1719	wxID_RESET,
	1720	wxID_CONTEXT_HELP,
	1721	wxID_YESTOALL,
	1722	wxID_NOTOALL,
	1723	wxID_ABORT,
	1724	wxID_RETRY,
	1725	wxID_IGNORE,
	1726	wxID_ADD,
	1727	wxID_REMOVE,
	1728
	1729	wxID_UP,
	1730	wxID_DOWN,
	1731	wxID_HOME,
	1732	wxID_REFRESH,
	1733	wxID_STOP,
	1734	wxID_INDEX,
	1735
	1736	wxID_BOLD,
	1737	wxID_ITALIC,
	1738	wxID_JUSTIFY_CENTER,
	1739	wxID_JUSTIFY_FILL,
	1740	wxID_JUSTIFY_RIGHT,
	1741	wxID_JUSTIFY_LEFT,
	1742	wxID_UNDERLINE,
	1743	wxID_INDENT,
	1744	wxID_UNINDENT,
	1745	wxID_ZOOM_100,
	1746	wxID_ZOOM_FIT,
	1747	wxID_ZOOM_IN,
	1748	wxID_ZOOM_OUT,
	1749	wxID_UNDELETE,
	1750	wxID_REVERT_TO_SAVED,
	1751
	1752	/* System menu IDs (used by wxUniv): */
	1753	wxID_SYSTEM_MENU = 5200,
	1754	wxID_CLOSE_FRAME,
	1755	wxID_MOVE_FRAME,
	1756	wxID_RESIZE_FRAME,
	1757	wxID_MAXIMIZE_FRAME,
	1758	wxID_ICONIZE_FRAME,
	1759	wxID_RESTORE_FRAME,
	1760
	1761	/* IDs used by generic file dialog (13 consecutive starting from this value) */
	1762	wxID_FILEDLGG = 5900,
	1763
	1764	wxID_HIGHEST = 5999
	1765	};
	1766
	1767	/* ---------------------------------------------------------------------------- */
	1768	/* other constants */
	1769	/* ---------------------------------------------------------------------------- */
	1770
	1771	/* menu and toolbar item kinds */
	1772	enum wxItemKind
	1773	{
	1774	wxITEM_SEPARATOR = -1,
	1775	wxITEM_NORMAL,
	1776	wxITEM_CHECK,
	1777	wxITEM_RADIO,
	1778	wxITEM_MAX
	1779	};
	1780
	1781	/* hit test results */
	1782	enum wxHitTest
	1783	{
	1784	wxHT_NOWHERE,
	1785
	1786	/* scrollbar */
	1787	wxHT_SCROLLBAR_FIRST = wxHT_NOWHERE,
	1788	wxHT_SCROLLBAR_ARROW_LINE_1, /* left or upper arrow to scroll by line */
	1789	wxHT_SCROLLBAR_ARROW_LINE_2, /* right or down */
	1790	wxHT_SCROLLBAR_ARROW_PAGE_1, /* left or upper arrow to scroll by page */
	1791	wxHT_SCROLLBAR_ARROW_PAGE_2, /* right or down */
	1792	wxHT_SCROLLBAR_THUMB, /* on the thumb */
	1793	wxHT_SCROLLBAR_BAR_1, /* bar to the left/above the thumb */
	1794	wxHT_SCROLLBAR_BAR_2, /* bar to the right/below the thumb */
	1795	wxHT_SCROLLBAR_LAST,
	1796
	1797	/* window */
	1798	wxHT_WINDOW_OUTSIDE, /* not in this window at all */
	1799	wxHT_WINDOW_INSIDE, /* in the client area */
	1800	wxHT_WINDOW_VERT_SCROLLBAR, /* on the vertical scrollbar */
	1801	wxHT_WINDOW_HORZ_SCROLLBAR, /* on the horizontal scrollbar */
	1802	wxHT_WINDOW_CORNER, /* on the corner between 2 scrollbars */
	1803
	1804	wxHT_MAX
	1805	};
	1806
	1807	/* ---------------------------------------------------------------------------- */
	1808	/* Possible SetSize flags */
	1809	/* ---------------------------------------------------------------------------- */
	1810
	1811	/* Use internally-calculated width if -1 */
	1812	#define wxSIZE_AUTO_WIDTH 0x0001
	1813	/* Use internally-calculated height if -1 */
	1814	#define wxSIZE_AUTO_HEIGHT 0x0002
	1815	/* Use internally-calculated width and height if each is -1 */
	1816	#define wxSIZE_AUTO (wxSIZE_AUTO_WIDTH\|wxSIZE_AUTO_HEIGHT)
	1817	/* Ignore missing (-1) dimensions (use existing). */
	1818	/* For readability only: test for wxSIZE_AUTO_WIDTH/HEIGHT in code. */
	1819	#define wxSIZE_USE_EXISTING 0x0000
	1820	/* Allow -1 as a valid position */
	1821	#define wxSIZE_ALLOW_MINUS_ONE 0x0004
	1822	/* Don't do parent client adjustments (for implementation only) */
	1823	#define wxSIZE_NO_ADJUSTMENTS 0x0008
	1824	/* Change the window position even if it seems to be already correct */
	1825	#define wxSIZE_FORCE 0x0010
	1826
	1827	/* ---------------------------------------------------------------------------- */
	1828	/* GDI descriptions */
	1829	/* ---------------------------------------------------------------------------- */
	1830
	1831	enum
	1832	{
	1833	/* Text font families */
	1834	wxDEFAULT = 70,
	1835	wxDECORATIVE,
	1836	wxROMAN,
	1837	wxSCRIPT,
	1838	wxSWISS,
	1839	wxMODERN,
	1840	wxTELETYPE, /* @@@@ */
	1841
	1842	/* Proportional or Fixed width fonts (not yet used) */
	1843	wxVARIABLE = 80,
	1844	wxFIXED,
	1845
	1846	wxNORMAL = 90,
	1847	wxLIGHT,
	1848	wxBOLD,
	1849	/* Also wxNORMAL for normal (non-italic text) */
	1850	wxITALIC,
	1851	wxSLANT,
	1852
	1853	/* Pen styles */
	1854	wxSOLID = 100,
	1855	wxDOT,
	1856	wxLONG_DASH,
	1857	wxSHORT_DASH,
	1858	wxDOT_DASH,
	1859	wxUSER_DASH,
	1860
	1861	wxTRANSPARENT,
	1862
	1863	/* Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */
	1864	/* Note also that stippling a Pen IS meaningfull, because a Line is */
	1865	wxSTIPPLE_MASK_OPAQUE, /* mask is used for blitting monochrome using text fore and back ground colors */
	1866	wxSTIPPLE_MASK, /* mask is used for masking areas in the stipple bitmap (TO DO) */
	1867	/* drawn with a Pen, and without any Brush -- and it can be stippled. */
	1868	wxSTIPPLE = 110,
	1869
	1870	wxBDIAGONAL_HATCH, /* In wxWidgets < 2.6 use WX_HATCH macro */
	1871	wxCROSSDIAG_HATCH, /* to verify these wx_HATCH are in style /
	1872	wxFDIAGONAL_HATCH, /* of wxBrush. In wxWidgets >= 2.6 use */
	1873	wxCROSS_HATCH, /* wxBrush::IsHatch() instead. */
	1874	wxHORIZONTAL_HATCH,
	1875	wxVERTICAL_HATCH,
	1876	wxFIRST_HATCH = wxBDIAGONAL_HATCH,
	1877	wxLAST_HATCH = wxVERTICAL_HATCH,
	1878
	1879	wxJOIN_BEVEL = 120,
	1880	wxJOIN_MITER,
	1881	wxJOIN_ROUND,
	1882
	1883	wxCAP_ROUND = 130,
	1884	wxCAP_PROJECTING,
	1885	wxCAP_BUTT
	1886	};
	1887
	1888	#if WXWIN_COMPATIBILITY_2_4
	1889	#define IS_HATCH(s) ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
	1890	#else
	1891	/* use wxBrush::IsHatch() instead thought wxMotif still uses it in src/motif/dcclient.cpp */
	1892	#endif
	1893
	1894	/* Logical ops */
	1895	typedef enum
	1896	{
	1897	wxCLEAR, wxROP_BLACK = wxCLEAR, wxBLIT_BLACKNESS = wxCLEAR, /* 0 */
	1898	wxXOR, wxROP_XORPEN = wxXOR, wxBLIT_SRCINVERT = wxXOR, /* src XOR dst */
	1899	wxINVERT, wxROP_NOT = wxINVERT, wxBLIT_DSTINVERT = wxINVERT, /* NOT dst */
	1900	wxOR_REVERSE, wxROP_MERGEPENNOT = wxOR_REVERSE, wxBLIT_00DD0228 = wxOR_REVERSE, /* src OR (NOT dst) */
	1901	wxAND_REVERSE, wxROP_MASKPENNOT = wxAND_REVERSE, wxBLIT_SRCERASE = wxAND_REVERSE, /* src AND (NOT dst) */
	1902	wxCOPY, wxROP_COPYPEN = wxCOPY, wxBLIT_SRCCOPY = wxCOPY, /* src */
	1903	wxAND, wxROP_MASKPEN = wxAND, wxBLIT_SRCAND = wxAND, /* src AND dst */
	1904	wxAND_INVERT, wxROP_MASKNOTPEN = wxAND_INVERT, wxBLIT_00220326 = wxAND_INVERT, /* (NOT src) AND dst */
	1905	wxNO_OP, wxROP_NOP = wxNO_OP, wxBLIT_00AA0029 = wxNO_OP, /* dst */
	1906	wxNOR, wxROP_NOTMERGEPEN = wxNOR, wxBLIT_NOTSRCERASE = wxNOR, /* (NOT src) AND (NOT dst) */
	1907	wxEQUIV, wxROP_NOTXORPEN = wxEQUIV, wxBLIT_00990066 = wxEQUIV, /* (NOT src) XOR dst */
	1908	wxSRC_INVERT, wxROP_NOTCOPYPEN = wxSRC_INVERT, wxBLIT_NOTSCRCOPY = wxSRC_INVERT, /* (NOT src) */
	1909	wxOR_INVERT, wxROP_MERGENOTPEN = wxOR_INVERT, wxBLIT_MERGEPAINT = wxOR_INVERT, /* (NOT src) OR dst */
	1910	wxNAND, wxROP_NOTMASKPEN = wxNAND, wxBLIT_007700E6 = wxNAND, /* (NOT src) OR (NOT dst) */
	1911	wxOR, wxROP_MERGEPEN = wxOR, wxBLIT_SRCPAINT = wxOR, /* src OR dst */
	1912	wxSET, wxROP_WHITE = wxSET, wxBLIT_WHITENESS = wxSET /* 1 */
	1913	} form_ops_t;
	1914
	1915	/* Flood styles */
	1916	enum
	1917	{
	1918	wxFLOOD_SURFACE = 1,
	1919	wxFLOOD_BORDER
	1920	};
	1921
	1922	/* Polygon filling mode */
	1923	enum
	1924	{
	1925	wxODDEVEN_RULE = 1,
	1926	wxWINDING_RULE
	1927	};
	1928
	1929	/* ToolPanel in wxFrame (VZ: unused?) */
	1930	enum
	1931	{
	1932	wxTOOL_TOP = 1,
	1933	wxTOOL_BOTTOM,
	1934	wxTOOL_LEFT,
	1935	wxTOOL_RIGHT
	1936	};
	1937
	1938	/* the values of the format constants should be the same as corresponding */
	1939	/* CF_XXX constants in Windows API */
	1940	enum wxDataFormatId
	1941	{
	1942	wxDF_INVALID = 0,
	1943	wxDF_TEXT = 1, /* CF_TEXT */
	1944	wxDF_BITMAP = 2, /* CF_BITMAP */
	1945	wxDF_METAFILE = 3, /* CF_METAFILEPICT */
	1946	wxDF_SYLK = 4,
	1947	wxDF_DIF = 5,
	1948	wxDF_TIFF = 6,
	1949	wxDF_OEMTEXT = 7, /* CF_OEMTEXT */
	1950	wxDF_DIB = 8, /* CF_DIB */
	1951	wxDF_PALETTE = 9,
	1952	wxDF_PENDATA = 10,
	1953	wxDF_RIFF = 11,
	1954	wxDF_WAVE = 12,
	1955	wxDF_UNICODETEXT = 13,
	1956	wxDF_ENHMETAFILE = 14,
	1957	wxDF_FILENAME = 15, /* CF_HDROP */
	1958	wxDF_LOCALE = 16,
	1959	wxDF_PRIVATE = 20,
	1960	wxDF_HTML = 30, /* Note: does not correspond to CF_ constant */
	1961	wxDF_MAX
	1962	};
	1963
	1964	/* Virtual keycodes */
	1965	enum wxKeyCode
	1966	{
	1967	WXK_BACK = 8,
	1968	WXK_TAB = 9,
	1969	WXK_RETURN = 13,
	1970	WXK_ESCAPE = 27,
	1971	WXK_SPACE = 32,
	1972	WXK_DELETE = 127,
	1973
	1974	/* These are, by design, not compatible with unicode characters.
	1975	If you want to get a unicode character from a key event, use
	1976	wxKeyEvent::GetUnicodeKey instead. */
	1977	WXK_START = 300,
	1978	WXK_LBUTTON,
	1979	WXK_RBUTTON,
	1980	WXK_CANCEL,
	1981	WXK_MBUTTON,
	1982	WXK_CLEAR,
	1983	WXK_SHIFT,
	1984	WXK_ALT,
	1985	WXK_CONTROL,
	1986	WXK_MENU,
	1987	WXK_PAUSE,
	1988	WXK_CAPITAL,
	1989	WXK_END,
	1990	WXK_HOME,
	1991	WXK_LEFT,
	1992	WXK_UP,
	1993	WXK_RIGHT,
	1994	WXK_DOWN,
	1995	WXK_SELECT,
	1996	WXK_PRINT,
	1997	WXK_EXECUTE,
	1998	WXK_SNAPSHOT,
	1999	WXK_INSERT,
	2000	WXK_HELP,
	2001	WXK_NUMPAD0,
	2002	WXK_NUMPAD1,
	2003	WXK_NUMPAD2,
	2004	WXK_NUMPAD3,
	2005	WXK_NUMPAD4,
	2006	WXK_NUMPAD5,
	2007	WXK_NUMPAD6,
	2008	WXK_NUMPAD7,
	2009	WXK_NUMPAD8,
	2010	WXK_NUMPAD9,
	2011	WXK_MULTIPLY,
	2012	WXK_ADD,
	2013	WXK_SEPARATOR,
	2014	WXK_SUBTRACT,
	2015	WXK_DECIMAL,
	2016	WXK_DIVIDE,
	2017	WXK_F1,
	2018	WXK_F2,
	2019	WXK_F3,
	2020	WXK_F4,
	2021	WXK_F5,
	2022	WXK_F6,
	2023	WXK_F7,
	2024	WXK_F8,
	2025	WXK_F9,
	2026	WXK_F10,
	2027	WXK_F11,
	2028	WXK_F12,
	2029	WXK_F13,
	2030	WXK_F14,
	2031	WXK_F15,
	2032	WXK_F16,
	2033	WXK_F17,
	2034	WXK_F18,
	2035	WXK_F19,
	2036	WXK_F20,
	2037	WXK_F21,
	2038	WXK_F22,
	2039	WXK_F23,
	2040	WXK_F24,
	2041	WXK_NUMLOCK,
	2042	WXK_SCROLL,
	2043	WXK_PAGEUP,
	2044	WXK_PAGEDOWN,
	2045	#if WXWIN_COMPATIBILITY_2_6
	2046	WXK_PRIOR = WXK_PAGEUP,
	2047	WXK_NEXT = WXK_PAGEDOWN,
	2048	#endif
	2049
	2050	WXK_NUMPAD_SPACE,
	2051	WXK_NUMPAD_TAB,
	2052	WXK_NUMPAD_ENTER,
	2053	WXK_NUMPAD_F1,
	2054	WXK_NUMPAD_F2,
	2055	WXK_NUMPAD_F3,
	2056	WXK_NUMPAD_F4,
	2057	WXK_NUMPAD_HOME,
	2058	WXK_NUMPAD_LEFT,
	2059	WXK_NUMPAD_UP,
	2060	WXK_NUMPAD_RIGHT,
	2061	WXK_NUMPAD_DOWN,
	2062	WXK_NUMPAD_PAGEUP,
	2063	WXK_NUMPAD_PAGEDOWN,
	2064	#if WXWIN_COMPATIBILITY_2_6
	2065	WXK_NUMPAD_PRIOR = WXK_NUMPAD_PAGEUP,
	2066	WXK_NUMPAD_NEXT = WXK_NUMPAD_PAGEDOWN,
	2067	#endif
	2068	WXK_NUMPAD_END,
	2069	WXK_NUMPAD_BEGIN,
	2070	WXK_NUMPAD_INSERT,
	2071	WXK_NUMPAD_DELETE,
	2072	WXK_NUMPAD_EQUAL,
	2073	WXK_NUMPAD_MULTIPLY,
	2074	WXK_NUMPAD_ADD,
	2075	WXK_NUMPAD_SEPARATOR,
	2076	WXK_NUMPAD_SUBTRACT,
	2077	WXK_NUMPAD_DECIMAL,
	2078	WXK_NUMPAD_DIVIDE,
	2079
	2080	WXK_WINDOWS_LEFT,
	2081	WXK_WINDOWS_RIGHT,
	2082	WXK_WINDOWS_MENU ,
	2083	WXK_COMMAND,
	2084
	2085	/* Hardware-specific buttons */
	2086	WXK_SPECIAL1 = 193,
	2087	WXK_SPECIAL2,
	2088	WXK_SPECIAL3,
	2089	WXK_SPECIAL4,
	2090	WXK_SPECIAL5,
	2091	WXK_SPECIAL6,
	2092	WXK_SPECIAL7,
	2093	WXK_SPECIAL8,
	2094	WXK_SPECIAL9,
	2095	WXK_SPECIAL10,
	2096	WXK_SPECIAL11,
	2097	WXK_SPECIAL12,
	2098	WXK_SPECIAL13,
	2099	WXK_SPECIAL14,
	2100	WXK_SPECIAL15,
	2101	WXK_SPECIAL16,
	2102	WXK_SPECIAL17,
	2103	WXK_SPECIAL18,
	2104	WXK_SPECIAL19,
	2105	WXK_SPECIAL20
	2106	};
	2107
	2108	/* This enum contains bit mask constants used in wxKeyEvent */
	2109	enum wxKeyModifier
	2110	{
	2111	wxMOD_NONE = 0x0000,
	2112	wxMOD_ALT = 0x0001,
	2113	wxMOD_CONTROL = 0x0002,
	2114	wxMOD_ALTGR = wxMOD_ALT \| wxMOD_CONTROL,
	2115	wxMOD_SHIFT = 0x0004,
	2116	wxMOD_META = 0x0008,
	2117	wxMOD_WIN = wxMOD_META,
	2118	#if defined(__WXMAC__) \|\| defined(__WXCOCOA__)
	2119	wxMOD_CMD = wxMOD_META,
	2120	#else
	2121	wxMOD_CMD = wxMOD_CONTROL,
	2122	#endif
	2123	wxMOD_ALL = 0xffff
	2124	};
	2125
	2126	/* Mapping modes (same values as used by Windows, don't change) */
	2127	enum
	2128	{
	2129	wxMM_TEXT = 1,
	2130	wxMM_LOMETRIC,
	2131	wxMM_HIMETRIC,
	2132	wxMM_LOENGLISH,
	2133	wxMM_HIENGLISH,
	2134	wxMM_TWIPS,
	2135	wxMM_ISOTROPIC,
	2136	wxMM_ANISOTROPIC,
	2137	wxMM_POINTS,
	2138	wxMM_METRIC
	2139	};
	2140
	2141	/* Shortcut for easier dialog-unit-to-pixel conversion */
	2142	#define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
	2143
	2144	/* Paper types */
	2145	typedef enum
	2146	{
	2147	wxPAPER_NONE, /* Use specific dimensions */
	2148	wxPAPER_LETTER, /* Letter, 8 1/2 by 11 inches */
	2149	wxPAPER_LEGAL, /* Legal, 8 1/2 by 14 inches */
	2150	wxPAPER_A4, /* A4 Sheet, 210 by 297 millimeters */
	2151	wxPAPER_CSHEET, /* C Sheet, 17 by 22 inches */
	2152	wxPAPER_DSHEET, /* D Sheet, 22 by 34 inches */
	2153	wxPAPER_ESHEET, /* E Sheet, 34 by 44 inches */
	2154	wxPAPER_LETTERSMALL, /* Letter Small, 8 1/2 by 11 inches */
	2155	wxPAPER_TABLOID, /* Tabloid, 11 by 17 inches */
	2156	wxPAPER_LEDGER, /* Ledger, 17 by 11 inches */
	2157	wxPAPER_STATEMENT, /* Statement, 5 1/2 by 8 1/2 inches */
	2158	wxPAPER_EXECUTIVE, /* Executive, 7 1/4 by 10 1/2 inches */
	2159	wxPAPER_A3, /* A3 sheet, 297 by 420 millimeters */
	2160	wxPAPER_A4SMALL, /* A4 small sheet, 210 by 297 millimeters */
	2161	wxPAPER_A5, /* A5 sheet, 148 by 210 millimeters */
	2162	wxPAPER_B4, /* B4 sheet, 250 by 354 millimeters */
	2163	wxPAPER_B5, /* B5 sheet, 182-by-257-millimeter paper */
	2164	wxPAPER_FOLIO, /* Folio, 8-1/2-by-13-inch paper */
	2165	wxPAPER_QUARTO, /* Quarto, 215-by-275-millimeter paper */
	2166	wxPAPER_10X14, /* 10-by-14-inch sheet */
	2167	wxPAPER_11X17, /* 11-by-17-inch sheet */
	2168	wxPAPER_NOTE, /* Note, 8 1/2 by 11 inches */
	2169	wxPAPER_ENV_9, /* #9 Envelope, 3 7/8 by 8 7/8 inches */
	2170	wxPAPER_ENV_10, /* #10 Envelope, 4 1/8 by 9 1/2 inches */
	2171	wxPAPER_ENV_11, /* #11 Envelope, 4 1/2 by 10 3/8 inches */
	2172	wxPAPER_ENV_12, /* #12 Envelope, 4 3/4 by 11 inches */
	2173	wxPAPER_ENV_14, /* #14 Envelope, 5 by 11 1/2 inches */
	2174	wxPAPER_ENV_DL, /* DL Envelope, 110 by 220 millimeters */
	2175	wxPAPER_ENV_C5, /* C5 Envelope, 162 by 229 millimeters */
	2176	wxPAPER_ENV_C3, /* C3 Envelope, 324 by 458 millimeters */
	2177	wxPAPER_ENV_C4, /* C4 Envelope, 229 by 324 millimeters */
	2178	wxPAPER_ENV_C6, /* C6 Envelope, 114 by 162 millimeters */
	2179	wxPAPER_ENV_C65, /* C65 Envelope, 114 by 229 millimeters */
	2180	wxPAPER_ENV_B4, /* B4 Envelope, 250 by 353 millimeters */
	2181	wxPAPER_ENV_B5, /* B5 Envelope, 176 by 250 millimeters */
	2182	wxPAPER_ENV_B6, /* B6 Envelope, 176 by 125 millimeters */
	2183	wxPAPER_ENV_ITALY, /* Italy Envelope, 110 by 230 millimeters */
	2184	wxPAPER_ENV_MONARCH, /* Monarch Envelope, 3 7/8 by 7 1/2 inches */
	2185	wxPAPER_ENV_PERSONAL, /* 6 3/4 Envelope, 3 5/8 by 6 1/2 inches */
	2186	wxPAPER_FANFOLD_US, /* US Std Fanfold, 14 7/8 by 11 inches */
	2187	wxPAPER_FANFOLD_STD_GERMAN, /* German Std Fanfold, 8 1/2 by 12 inches */
	2188	wxPAPER_FANFOLD_LGL_GERMAN, /* German Legal Fanfold, 8 1/2 by 13 inches */
	2189
	2190	wxPAPER_ISO_B4, /* B4 (ISO) 250 x 353 mm */
	2191	wxPAPER_JAPANESE_POSTCARD, /* Japanese Postcard 100 x 148 mm */
	2192	wxPAPER_9X11, /* 9 x 11 in */
	2193	wxPAPER_10X11, /* 10 x 11 in */
	2194	wxPAPER_15X11, /* 15 x 11 in */
	2195	wxPAPER_ENV_INVITE, /* Envelope Invite 220 x 220 mm */
	2196	wxPAPER_LETTER_EXTRA, /* Letter Extra 9 \275 x 12 in */
	2197	wxPAPER_LEGAL_EXTRA, /* Legal Extra 9 \275 x 15 in */
	2198	wxPAPER_TABLOID_EXTRA, /* Tabloid Extra 11.69 x 18 in */
	2199	wxPAPER_A4_EXTRA, /* A4 Extra 9.27 x 12.69 in */
	2200	wxPAPER_LETTER_TRANSVERSE, /* Letter Transverse 8 \275 x 11 in */
	2201	wxPAPER_A4_TRANSVERSE, /* A4 Transverse 210 x 297 mm */
	2202	wxPAPER_LETTER_EXTRA_TRANSVERSE, /* Letter Extra Transverse 9\275 x 12 in */
	2203	wxPAPER_A_PLUS, /* SuperA/SuperA/A4 227 x 356 mm */
	2204	wxPAPER_B_PLUS, /* SuperB/SuperB/A3 305 x 487 mm */
	2205	wxPAPER_LETTER_PLUS, /* Letter Plus 8.5 x 12.69 in */
	2206	wxPAPER_A4_PLUS, /* A4 Plus 210 x 330 mm */
	2207	wxPAPER_A5_TRANSVERSE, /* A5 Transverse 148 x 210 mm */
	2208	wxPAPER_B5_TRANSVERSE, /* B5 (JIS) Transverse 182 x 257 mm */
	2209	wxPAPER_A3_EXTRA, /* A3 Extra 322 x 445 mm */
	2210	wxPAPER_A5_EXTRA, /* A5 Extra 174 x 235 mm */
	2211	wxPAPER_B5_EXTRA, /* B5 (ISO) Extra 201 x 276 mm */
	2212	wxPAPER_A2, /* A2 420 x 594 mm */
	2213	wxPAPER_A3_TRANSVERSE, /* A3 Transverse 297 x 420 mm */
	2214	wxPAPER_A3_EXTRA_TRANSVERSE, /* A3 Extra Transverse 322 x 445 mm */
	2215
	2216	wxPAPER_DBL_JAPANESE_POSTCARD,/* Japanese Double Postcard 200 x 148 mm */
	2217	wxPAPER_A6, /* A6 105 x 148 mm */
	2218	wxPAPER_JENV_KAKU2, /* Japanese Envelope Kaku #2 */
	2219	wxPAPER_JENV_KAKU3, /* Japanese Envelope Kaku #3 */
	2220	wxPAPER_JENV_CHOU3, /* Japanese Envelope Chou #3 */
	2221	wxPAPER_JENV_CHOU4, /* Japanese Envelope Chou #4 */
	2222	wxPAPER_LETTER_ROTATED, /* Letter Rotated 11 x 8 1/2 in */
	2223	wxPAPER_A3_ROTATED, /* A3 Rotated 420 x 297 mm */
	2224	wxPAPER_A4_ROTATED, /* A4 Rotated 297 x 210 mm */
	2225	wxPAPER_A5_ROTATED, /* A5 Rotated 210 x 148 mm */
	2226	wxPAPER_B4_JIS_ROTATED, /* B4 (JIS) Rotated 364 x 257 mm */
	2227	wxPAPER_B5_JIS_ROTATED, /* B5 (JIS) Rotated 257 x 182 mm */
	2228	wxPAPER_JAPANESE_POSTCARD_ROTATED,/* Japanese Postcard Rotated 148 x 100 mm */
	2229	wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED,/* Double Japanese Postcard Rotated 148 x 200 mm */
	2230	wxPAPER_A6_ROTATED, /* A6 Rotated 148 x 105 mm */
	2231	wxPAPER_JENV_KAKU2_ROTATED, /* Japanese Envelope Kaku #2 Rotated */
	2232	wxPAPER_JENV_KAKU3_ROTATED, /* Japanese Envelope Kaku #3 Rotated */
	2233	wxPAPER_JENV_CHOU3_ROTATED, /* Japanese Envelope Chou #3 Rotated */
	2234	wxPAPER_JENV_CHOU4_ROTATED, /* Japanese Envelope Chou #4 Rotated */
	2235	wxPAPER_B6_JIS, /* B6 (JIS) 128 x 182 mm */
	2236	wxPAPER_B6_JIS_ROTATED, /* B6 (JIS) Rotated 182 x 128 mm */
	2237	wxPAPER_12X11, /* 12 x 11 in */
	2238	wxPAPER_JENV_YOU4, /* Japanese Envelope You #4 */
	2239	wxPAPER_JENV_YOU4_ROTATED, /* Japanese Envelope You #4 Rotated */
	2240	wxPAPER_P16K, /* PRC 16K 146 x 215 mm */
	2241	wxPAPER_P32K, /* PRC 32K 97 x 151 mm */
	2242	wxPAPER_P32KBIG, /* PRC 32K(Big) 97 x 151 mm */
	2243	wxPAPER_PENV_1, /* PRC Envelope #1 102 x 165 mm */
	2244	wxPAPER_PENV_2, /* PRC Envelope #2 102 x 176 mm */
	2245	wxPAPER_PENV_3, /* PRC Envelope #3 125 x 176 mm */
	2246	wxPAPER_PENV_4, /* PRC Envelope #4 110 x 208 mm */
	2247	wxPAPER_PENV_5, /* PRC Envelope #5 110 x 220 mm */
	2248	wxPAPER_PENV_6, /* PRC Envelope #6 120 x 230 mm */
	2249	wxPAPER_PENV_7, /* PRC Envelope #7 160 x 230 mm */
	2250	wxPAPER_PENV_8, /* PRC Envelope #8 120 x 309 mm */
	2251	wxPAPER_PENV_9, /* PRC Envelope #9 229 x 324 mm */
	2252	wxPAPER_PENV_10, /* PRC Envelope #10 324 x 458 mm */
	2253	wxPAPER_P16K_ROTATED, /* PRC 16K Rotated */
	2254	wxPAPER_P32K_ROTATED, /* PRC 32K Rotated */
	2255	wxPAPER_P32KBIG_ROTATED, /* PRC 32K(Big) Rotated */
	2256	wxPAPER_PENV_1_ROTATED, /* PRC Envelope #1 Rotated 165 x 102 mm */
	2257	wxPAPER_PENV_2_ROTATED, /* PRC Envelope #2 Rotated 176 x 102 mm */
	2258	wxPAPER_PENV_3_ROTATED, /* PRC Envelope #3 Rotated 176 x 125 mm */
	2259	wxPAPER_PENV_4_ROTATED, /* PRC Envelope #4 Rotated 208 x 110 mm */
	2260	wxPAPER_PENV_5_ROTATED, /* PRC Envelope #5 Rotated 220 x 110 mm */
	2261	wxPAPER_PENV_6_ROTATED, /* PRC Envelope #6 Rotated 230 x 120 mm */
	2262	wxPAPER_PENV_7_ROTATED, /* PRC Envelope #7 Rotated 230 x 160 mm */
	2263	wxPAPER_PENV_8_ROTATED, /* PRC Envelope #8 Rotated 309 x 120 mm */
	2264	wxPAPER_PENV_9_ROTATED, /* PRC Envelope #9 Rotated 324 x 229 mm */
	2265	wxPAPER_PENV_10_ROTATED /* PRC Envelope #10 Rotated 458 x 324 m */
	2266	} wxPaperSize;
	2267
	2268	/* Printing orientation */
	2269	#ifndef wxPORTRAIT
	2270	#define wxPORTRAIT 1
	2271	#define wxLANDSCAPE 2
	2272	#endif
	2273
	2274	/* Duplex printing modes
	2275	*/
	2276
	2277	enum wxDuplexMode
	2278	{
	2279	wxDUPLEX_SIMPLEX, /* Non-duplex */
	2280	wxDUPLEX_HORIZONTAL,
	2281	wxDUPLEX_VERTICAL
	2282	};
	2283
	2284	/* Print quality.
	2285	*/
	2286
	2287	#define wxPRINT_QUALITY_HIGH -1
	2288	#define wxPRINT_QUALITY_MEDIUM -2
	2289	#define wxPRINT_QUALITY_LOW -3
	2290	#define wxPRINT_QUALITY_DRAFT -4
	2291
	2292	typedef int wxPrintQuality;
	2293
	2294	/* Print mode (currently PostScript only)
	2295	*/
	2296
	2297	enum wxPrintMode
	2298	{
	2299	wxPRINT_MODE_NONE = 0,
	2300	wxPRINT_MODE_PREVIEW = 1, /* Preview in external application */
	2301	wxPRINT_MODE_FILE = 2, /* Print to file */
	2302	wxPRINT_MODE_PRINTER = 3, /* Send to printer */
	2303	wxPRINT_MODE_STREAM = 4 /* Send postscript data into a stream */
	2304	};
	2305
	2306	/* ---------------------------------------------------------------------------- */
	2307	/* UpdateWindowUI flags */
	2308	/* ---------------------------------------------------------------------------- */
	2309
	2310	enum wxUpdateUI
	2311	{
	2312	wxUPDATE_UI_NONE = 0x0000,
	2313	wxUPDATE_UI_RECURSE = 0x0001,
	2314	wxUPDATE_UI_FROMIDLE = 0x0002 /* Invoked from On(Internal)Idle */
	2315	};
	2316
	2317	/* ---------------------------------------------------------------------------- */
	2318	/* miscellaneous */
	2319	/* ---------------------------------------------------------------------------- */
	2320
	2321	/* define this macro if font handling is done using the X font names */
	2322	#if (defined(__WXGTK__) && !defined(__WXGTK20__)) \|\| defined(__X__)
	2323	#define _WX_X_FONTLIKE
	2324	#endif
	2325
	2326	/* macro to specify "All Files" on different platforms */
	2327	#if defined(__WXMSW__) \|\| defined(__WXPM__)
	2328	# define wxALL_FILES_PATTERN wxT(".")
	2329	# define wxALL_FILES gettext_noop("All files (.)\|.")
	2330	#else
	2331	# define wxALL_FILES_PATTERN wxT("*")
	2332	# define wxALL_FILES gettext_noop("All files ()\|")
	2333	#endif
	2334
	2335	#if defined(__CYGWIN__) && defined(__WXMSW__)
	2336	# if wxUSE_STL \|\| defined(wxUSE_STD_STRING)
	2337	/*
	2338	NASTY HACK because the gethostname in sys/unistd.h which the gnu
	2339	stl includes and wx builds with by default clash with each other
	2340	(windows version 2nd param is int, sys/unistd.h version is unsigned
	2341	int).
	2342	*/
	2343	# define gethostname gethostnameHACK
	2344	# include <unistd.h>
	2345	# undef gethostname
	2346	# endif
	2347	#endif
	2348
	2349	/* --------------------------------------------------------------------------- */
	2350	/* macros that enable wxWidgets apps to be compiled in absence of the */
	2351	/* sytem headers, although some platform specific types are used in the */
	2352	/* platform specific (implementation) parts of the headers */
	2353	/* --------------------------------------------------------------------------- */
	2354
	2355	#ifdef __WXMAC__
	2356
	2357	#define WX_OPAQUE_TYPE( name ) struct wxOpaque##name
	2358
	2359	typedef unsigned char WXCOLORREF[6];
	2360	typedef void* WXCGIMAGEREF;
	2361	typedef void* WXHBITMAP;
	2362	typedef void* WXHCURSOR;
	2363	typedef void* WXHRGN;
	2364	typedef void* WXRECTPTR;
	2365	typedef void* WXPOINTPTR;
	2366	typedef void* WXHWND;
	2367	typedef void* WXEVENTREF;
	2368	typedef void* WXEVENTHANDLERREF;
	2369	typedef void* WXEVENTHANDLERCALLREF;
	2370	typedef void* WXAPPLEEVENTREF;
	2371	typedef void* WXHDC;
	2372	typedef void* WXHMENU;
	2373	typedef unsigned int WXUINT;
	2374	typedef unsigned long WXDWORD;
	2375	typedef unsigned short WXWORD;
	2376
	2377	typedef WX_OPAQUE_TYPE(CIconHandle ) * WXHICON ;
	2378	typedef WX_OPAQUE_TYPE(PicHandle ) * WXHMETAFILE ;
	2379
	2380
	2381	/* typedef void* WXWidget; */
	2382	/* typedef void* WXWindow; */
	2383	typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ;
	2384	typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ;
	2385	typedef void* WXDisplay;
	2386
	2387	/* typedef WindowPtr WXHWND; */
	2388	/* typedef Handle WXHANDLE; */
	2389	/* typedef CIconHandle WXHICON; */
	2390	/* typedef unsigned long WXHFONT; */
	2391	/* typedef MenuHandle WXHMENU; */
	2392	/* typedef unsigned long WXHPEN; */
	2393	/* typedef unsigned long WXHBRUSH; */
	2394	/* typedef unsigned long WXHPALETTE; */
	2395	/* typedef CursHandle WXHCURSOR; */
	2396	/* typedef RgnHandle WXHRGN; */
	2397	/* typedef unsigned long WXHACCEL; */
	2398	/* typedef unsigned long WXHINSTANCE; */
	2399	/* typedef unsigned long WXHIMAGELIST; */
	2400	/* typedef unsigned long WXHGLOBAL; */
	2401	/* typedef GrafPtr WXHDC; */
	2402	/* typedef unsigned int WXWPARAM; */
	2403	/* typedef long WXLPARAM; */
	2404	/* typedef void * WXRGNDATA; */
	2405	/* typedef void * WXMSG; */
	2406	/* typedef unsigned long WXHCONV; */
	2407	/* typedef unsigned long WXHKEY; */
	2408	/* typedef void * WXDRAWITEMSTRUCT; */
	2409	/* typedef void * WXMEASUREITEMSTRUCT; */
	2410	/* typedef void * WXLPCREATESTRUCT; */
	2411	/* typedef int (WXFARPROC)(); /
	2412
	2413	/* typedef WindowPtr WXWindow; */
	2414	/* typedef ControlHandle WXWidget; */
	2415
	2416	#endif
	2417
	2418	#ifdef __WXCOCOA__
	2419
	2420	/* NOTE: This ought to work with other compilers too, but I'm being cautious */
	2421	#if (defined(__GNUC__) && defined(__APPLE__)) \|\| defined(__MWERKS__)
	2422	/* It's desirable to have type safety for Objective-C(++) code as it does
	2423	at least catch typos of method names among other things. However, it
	2424	is not possible to declare an Objective-C class from plain old C or C++
	2425	code. Furthermore, because of C++ name mangling, the type name must
	2426	be the same for both C++ and Objective-C++ code. Therefore, we define
	2427	what should be a pointer to an Objective-C class as a pointer to a plain
	2428	old C struct with the same name. Unfortunately, because the compiler
	2429	does not see a struct as an Objective-C class we cannot declare it
	2430	as a struct in Objective-C(++) mode.
	2431	*/
	2432	#if defined(__OBJC__)
	2433	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2434	@class klass; \
	2435	typedef klass *WX_##klass
	2436	#else /* not defined(__OBJC__) */
	2437	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2438	typedef struct klass *WX_##klass
	2439	#endif /* defined(__OBJC__) */
	2440
	2441	#else /* not Apple's GNU or CodeWarrior */
	2442	#warning "Objective-C types will not be checked by the compiler."
	2443	/* NOTE: typedef struct objc_object id; /
	2444	/* IOW, we're declaring these using the id type without using that name, */
	2445	/* since "id" is used extensively not only within wxWidgets itself, but */
	2446	/* also in wxWidgets application code. The following works fine when */
	2447	/* compiling C(++) code, and works without typesafety for Obj-C(++) code */
	2448	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2449	typedef struct objc_object *WX_##klass
	2450
	2451	#endif /* (defined(__GNUC__) && defined(__APPLE__)) \|\| defined(__MWERKS__) */
	2452
	2453	DECLARE_WXCOCOA_OBJC_CLASS(NSApplication);
	2454	DECLARE_WXCOCOA_OBJC_CLASS(NSBitmapImageRep);
	2455	DECLARE_WXCOCOA_OBJC_CLASS(NSBox);
	2456	DECLARE_WXCOCOA_OBJC_CLASS(NSButton);
	2457	DECLARE_WXCOCOA_OBJC_CLASS(NSColor);
	2458	DECLARE_WXCOCOA_OBJC_CLASS(NSColorPanel);
	2459	DECLARE_WXCOCOA_OBJC_CLASS(NSControl);
	2460	DECLARE_WXCOCOA_OBJC_CLASS(NSCursor);
	2461	DECLARE_WXCOCOA_OBJC_CLASS(NSEvent);
	2462	DECLARE_WXCOCOA_OBJC_CLASS(NSFontPanel);
	2463	DECLARE_WXCOCOA_OBJC_CLASS(NSImage);
	2464	DECLARE_WXCOCOA_OBJC_CLASS(NSLayoutManager);
	2465	DECLARE_WXCOCOA_OBJC_CLASS(NSMenu);
	2466	DECLARE_WXCOCOA_OBJC_CLASS(NSMenuExtra);
	2467	DECLARE_WXCOCOA_OBJC_CLASS(NSMenuItem);
	2468	DECLARE_WXCOCOA_OBJC_CLASS(NSMutableArray);
	2469	DECLARE_WXCOCOA_OBJC_CLASS(NSNotification);
	2470	DECLARE_WXCOCOA_OBJC_CLASS(NSObject);
	2471	DECLARE_WXCOCOA_OBJC_CLASS(NSPanel);
	2472	DECLARE_WXCOCOA_OBJC_CLASS(NSScrollView);
	2473	DECLARE_WXCOCOA_OBJC_CLASS(NSSound);
	2474	DECLARE_WXCOCOA_OBJC_CLASS(NSStatusItem);
	2475	DECLARE_WXCOCOA_OBJC_CLASS(NSTableColumn);
	2476	DECLARE_WXCOCOA_OBJC_CLASS(NSTableView);
	2477	DECLARE_WXCOCOA_OBJC_CLASS(NSTextContainer);
	2478	DECLARE_WXCOCOA_OBJC_CLASS(NSTextField);
	2479	DECLARE_WXCOCOA_OBJC_CLASS(NSTextStorage);
	2480	DECLARE_WXCOCOA_OBJC_CLASS(NSThread);
	2481	DECLARE_WXCOCOA_OBJC_CLASS(NSWindow);
	2482	DECLARE_WXCOCOA_OBJC_CLASS(NSView);
	2483	typedef WX_NSView WXWidget; /* wxWidgets BASE definition */
	2484	#endif /* __WXCOCOA__ */
	2485
	2486	#if defined(__WXPALMOS__)
	2487
	2488	typedef void * WXHWND;
	2489	typedef void * WXHANDLE;
	2490	typedef void * WXHICON;
	2491	typedef void * WXHFONT;
	2492	typedef void * WXHMENU;
	2493	typedef void * WXHPEN;
	2494	typedef void * WXHBRUSH;
	2495	typedef void * WXHPALETTE;
	2496	typedef void * WXHCURSOR;
	2497	typedef void * WXHRGN;
	2498	typedef void * WXHACCEL;
	2499	typedef void * WXHINSTANCE;
	2500	typedef void * WXHBITMAP;
	2501	typedef void * WXHIMAGELIST;
	2502	typedef void * WXHGLOBAL;
	2503	typedef void * WXHDC;
	2504	typedef unsigned int WXUINT;
	2505	typedef unsigned long WXDWORD;
	2506	typedef unsigned short WXWORD;
	2507
	2508	typedef unsigned long WXCOLORREF;
	2509	typedef struct tagMSG WXMSG;
	2510
	2511	typedef WXHWND WXWINHANDLE; /* WinHandle of PalmOS */
	2512	typedef WXWINHANDLE WXWidget;
	2513
	2514	typedef void * WXFORMPTR;
	2515	typedef void * WXEVENTPTR;
	2516	typedef void * WXRECTANGLEPTR;
	2517
	2518	#endif /* __WXPALMOS__ */
	2519
	2520
	2521	/* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
	2522	#if defined(__WIN32__)
	2523
	2524	/* the keywords needed for WinMain() declaration */
	2525	#ifndef WXFAR
	2526	# define WXFAR
	2527	#endif
	2528
	2529	/* Stand-ins for Windows types to avoid #including all of windows.h */
	2530	typedef void * WXHWND;
	2531	typedef void * WXHANDLE;
	2532	typedef void * WXHICON;
	2533	typedef void * WXHFONT;
	2534	typedef void * WXHMENU;
	2535	typedef void * WXHPEN;
	2536	typedef void * WXHBRUSH;
	2537	typedef void * WXHPALETTE;
	2538	typedef void * WXHCURSOR;
	2539	typedef void * WXHRGN;
	2540	typedef void * WXRECTPTR;
	2541	typedef void * WXHACCEL;
	2542	typedef void WXFAR * WXHINSTANCE;
	2543	typedef void * WXHBITMAP;
	2544	typedef void * WXHIMAGELIST;
	2545	typedef void * WXHGLOBAL;
	2546	typedef void * WXHDC;
	2547	typedef unsigned int WXUINT;
	2548	typedef unsigned long WXDWORD;
	2549	typedef unsigned short WXWORD;
	2550
	2551	typedef unsigned long WXCOLORREF;
	2552	typedef void * WXRGNDATA;
	2553	typedef struct tagMSG WXMSG;
	2554	typedef void * WXHCONV;
	2555	typedef void * WXHKEY;
	2556	typedef void * WXHTREEITEM;
	2557
	2558	typedef void * WXDRAWITEMSTRUCT;
	2559	typedef void * WXMEASUREITEMSTRUCT;
	2560	typedef void * WXLPCREATESTRUCT;
	2561
	2562	typedef WXHWND WXWidget;
	2563
	2564	#ifdef __WIN64__
	2565	typedef unsigned __int64 WXWPARAM;
	2566	typedef __int64 WXLPARAM;
	2567	typedef __int64 WXLRESULT;
	2568	#else
	2569	typedef unsigned int WXWPARAM;
	2570	typedef long WXLPARAM;
	2571	typedef long WXLRESULT;
	2572	#endif
	2573
	2574	#if defined(__GNUWIN32__) \|\| defined(__WXMICROWIN__)
	2575	typedef int (*WXFARPROC)();
	2576	#else
	2577	typedef int (__stdcall *WXFARPROC)();
	2578	#endif
	2579	#endif /* __WIN32__ */
	2580
	2581
	2582	#if defined(__OS2__)
	2583	typedef unsigned long DWORD;
	2584	typedef unsigned short WORD;
	2585	#endif
	2586
	2587	#if defined(__WXPM__) \|\| defined(__EMX__)
	2588	#ifdef __WXPM__
	2589	/* Stand-ins for OS/2 types, to avoid #including all of os2.h */
	2590	typedef unsigned long WXHWND;
	2591	typedef unsigned long WXHANDLE;
	2592	typedef unsigned long WXHICON;
	2593	typedef unsigned long WXHFONT;
	2594	typedef unsigned long WXHMENU;
	2595	typedef unsigned long WXHPEN;
	2596	typedef unsigned long WXHBRUSH;
	2597	typedef unsigned long WXHPALETTE;
	2598	typedef unsigned long WXHCURSOR;
	2599	typedef unsigned long WXHRGN;
	2600	typedef unsigned long WXHACCEL;
	2601	typedef unsigned long WXHBITMAP;
	2602	typedef unsigned long WXHDC;
	2603	typedef unsigned int WXUINT;
	2604	typedef unsigned long WXDWORD;
	2605	typedef unsigned short WXWORD;
	2606
	2607	typedef unsigned long WXCOLORREF;
	2608	typedef void * WXMSG;
	2609	typedef unsigned long WXHTREEITEM;
	2610
	2611	typedef void * WXDRAWITEMSTRUCT;
	2612	typedef void * WXMEASUREITEMSTRUCT;
	2613	typedef void * WXLPCREATESTRUCT;
	2614
	2615	typedef WXHWND WXWidget;
	2616	#endif
	2617	#ifdef __EMX__
	2618	/* Need a well-known type for WXFARPROC
	2619	below. MPARAM is typedef'ed too late. */
	2620	#define WXWPARAM void *
	2621	#define WXLPARAM void *
	2622	#else
	2623	#define WXWPARAM MPARAM
	2624	#define WXLPARAM MPARAM
	2625	#endif
	2626	#define RECT RECTL
	2627	#define LOGFONT FATTRS
	2628	#define LOWORD SHORT1FROMMP
	2629	#define HIWORD SHORT2FROMMP
	2630
	2631	typedef unsigned long WXMPARAM;
	2632	typedef unsigned long WXMSGID;
	2633	typedef void* WXRESULT;
	2634	/* typedef int (WXFARPROC)(); /
	2635	/* some windows handles not defined by PM */
	2636	typedef unsigned long HANDLE;
	2637	typedef unsigned long HICON;
	2638	typedef unsigned long HFONT;
	2639	typedef unsigned long HMENU;
	2640	typedef unsigned long HPEN;
	2641	typedef unsigned long HBRUSH;
	2642	typedef unsigned long HPALETTE;
	2643	typedef unsigned long HCURSOR;
	2644	typedef unsigned long HINSTANCE;
	2645	typedef unsigned long HIMAGELIST;
	2646	typedef unsigned long HGLOBAL;
	2647	#endif /* WXPM \|\| EMX */
	2648
	2649	#if defined (__WXPM__)
	2650	/* WIN32 graphics types for OS/2 GPI */
	2651
	2652	/* RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def */
	2653	#define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) \| ((unsigned char)(g) << 8)) \| ((unsigned char)(r) << 16))
	2654
	2655	typedef unsigned long COLORREF;
	2656	#define GetRValue(rgb) ((unsigned char)((rgb) >> 16))
	2657	#define GetGValue(rgb) ((unsigned char)(((unsigned short)(rgb)) >> 8))
	2658	#define GetBValue(rgb) ((unsigned char)(rgb))
	2659	#define PALETTEINDEX(i) ((COLORREF)(0x01000000 \| (DWORD)(WORD)(i)))
	2660	#define PALETTERGB(r,g,b) (0x02000000 \| OS2RGB(r,g,b))
	2661	/* OS2's RGB/RGB2 is backwards from this */
	2662	typedef struct tagPALETTEENTRY
	2663	{
	2664	char bRed;
	2665	char bGreen;
	2666	char bBlue;
	2667	char bFlags;
	2668	} PALETTEENTRY;
	2669	typedef struct tagLOGPALETTE
	2670	{
	2671	WORD palVersion;
	2672	WORD palNumentries;
	2673	WORD PALETTEENTRY[1];
	2674	} LOGPALETTE;
	2675
	2676	#if (defined(__VISAGECPP__) && (__IBMCPP__ < 400)) \|\| defined (__WATCOMC__)
	2677	/* VA 3.0 for some reason needs base data types when typedefing a proc proto??? */
	2678	typedef void* (_System WXFARPROC)(unsigned long, unsigned long, void, void*);
	2679	#else
	2680	#if defined(__EMX__) && !defined(_System)
	2681	#define _System
	2682	#endif
	2683	typedef WXRESULT (_System *WXFARPROC)(WXHWND, WXMSGID, WXWPARAM, WXLPARAM);
	2684	#endif
	2685
	2686	#endif /* __WXPM__ */
	2687
	2688
	2689	#if defined(__WXMOTIF__) \|\| defined(__WXX11__)
	2690	/* Stand-ins for X/Xt/Motif types */
	2691	typedef void* WXWindow;
	2692	typedef void* WXWidget;
	2693	typedef void* WXAppContext;
	2694	typedef void* WXColormap;
	2695	typedef void* WXColor;
	2696	typedef void WXDisplay;
	2697	typedef void WXEvent;
	2698	typedef void* WXCursor;
	2699	typedef void* WXPixmap;
	2700	typedef void* WXFontStructPtr;
	2701	typedef void* WXGC;
	2702	typedef void* WXRegion;
	2703	typedef void* WXFont;
	2704	typedef void* WXImage;
	2705	typedef void* WXFontList;
	2706	typedef void* WXFontSet;
	2707	typedef void* WXRendition;
	2708	typedef void* WXRenderTable;
	2709	typedef void* WXFontType; /* either a XmFontList or XmRenderTable */
	2710	typedef void* WXString;
	2711
	2712	typedef unsigned long Atom; /* this might fail on a few architectures */
	2713	typedef long WXPixel; /* safety catch in src/motif/colour.cpp */
	2714
	2715	#endif /* Motif */
	2716
	2717	#ifdef __WXGTK__
	2718
	2719	/* Stand-ins for GLIB types */
	2720	typedef char gchar;
	2721	typedef signed char gint8;
	2722	typedef int gint;
	2723	typedef unsigned guint;
	2724	typedef unsigned long gulong;
	2725	typedef void* gpointer;
	2726	typedef struct _GSList GSList;
	2727
	2728	/* Stand-ins for GDK types */
	2729	typedef struct _GdkColor GdkColor;
	2730	typedef struct _GdkColormap GdkColormap;
	2731	typedef struct _GdkFont GdkFont;
	2732	typedef struct _GdkGC GdkGC;
	2733	typedef struct _GdkVisual GdkVisual;
	2734
	2735	#ifdef __WXGTK20__
	2736	typedef struct _GdkAtom *GdkAtom;
	2737	typedef struct _GdkDrawable GdkWindow;
	2738	typedef struct _GdkDrawable GdkBitmap;
	2739	typedef struct _GdkDrawable GdkPixmap;
	2740	#else /* GTK+ 1.2 */
	2741	typedef gulong GdkAtom;
	2742	typedef struct _GdkWindow GdkWindow;
	2743	typedef struct _GdkWindow GdkBitmap;
	2744	typedef struct _GdkWindow GdkPixmap;
	2745	#endif /* GTK+ 1.2/2.0 */
	2746
	2747	typedef struct _GdkCursor GdkCursor;
	2748	typedef struct _GdkRegion GdkRegion;
	2749	typedef struct _GdkDragContext GdkDragContext;
	2750
	2751	#ifdef HAVE_XIM
	2752	typedef struct _GdkIC GdkIC;
	2753	typedef struct _GdkICAttr GdkICAttr;
	2754	#endif
	2755
	2756	/* Stand-ins for GTK types */
	2757	typedef struct _GtkWidget GtkWidget;
	2758	typedef struct _GtkRcStyle GtkRcStyle;
	2759	typedef struct _GtkAdjustment GtkAdjustment;
	2760	typedef struct _GtkList GtkList;
	2761	typedef struct _GtkToolbar GtkToolbar;
	2762	typedef struct _GtkTooltips GtkTooltips;
	2763	typedef struct _GtkNotebook GtkNotebook;
	2764	typedef struct _GtkNotebookPage GtkNotebookPage;
	2765	typedef struct _GtkAccelGroup GtkAccelGroup;
	2766	typedef struct _GtkItemFactory GtkItemFactory;
	2767	typedef struct _GtkSelectionData GtkSelectionData;
	2768	typedef struct _GtkTextBuffer GtkTextBuffer;
	2769	typedef struct _GtkRange GtkRange;
	2770
	2771	typedef GtkWidget *WXWidget;
	2772
	2773	#ifndef __WXGTK20__
	2774	#define GTK_OBJECT_GET_CLASS(object) (GTK_OBJECT(object)->klass)
	2775	#define GTK_CLASS_TYPE(klass) ((klass)->type)
	2776	#endif
	2777
	2778	#ifdef __WXGTK20__
	2779	#define G_DISABLE_DEPRECATED
	2780	#define PANGO_DISABLE_DEPRECATED
	2781	#define GDK_PIXBUF_DISABLE_DEPRECATED
	2782	#ifndef __VMS
	2783	/* GtkCombo is not defined on VMS if this is defined */
	2784	# define GTK_DISABLE_DEPRECATED
	2785	#endif
	2786	#endif
	2787
	2788	#endif /* __WXGTK__ */
	2789
	2790	#if defined(__WXGTK20__) \|\| (defined(__WXX11__) && wxUSE_UNICODE)
	2791	#define wxUSE_PANGO 1
	2792	#else
	2793	#define wxUSE_PANGO 0
	2794	#endif
	2795
	2796	#if wxUSE_PANGO
	2797	/* Stand-ins for Pango types */
	2798	typedef struct _PangoContext PangoContext;
	2799	typedef struct _PangoLayout PangoLayout;
	2800	typedef struct _PangoFontDescription PangoFontDescription;
	2801	#endif
	2802
	2803	#ifdef __WXMGL__
	2804	typedef struct window_t *WXWidget;
	2805	#endif /* MGL */
	2806
	2807	#ifdef __WXDFB__
	2808	/* DirectFB doesn't have the concept of non-TLW window, so use
	2809	something arbitrary */
	2810	typedef const void* WXWidget;
	2811	#endif /* DFB */
	2812
	2813	/* This is required because of clashing macros in windows.h, which may be */
	2814	/* included before or after wxWidgets classes, and therefore must be */
	2815	/* disabled here before any significant wxWidgets headers are included. */
	2816	#ifdef __WXMSW__
	2817	#ifdef GetClassInfo
	2818	#undef GetClassInfo
	2819	#endif
	2820
	2821	#ifdef GetClassName
	2822	#undef GetClassName
	2823	#endif
	2824
	2825	#ifdef DrawText
	2826	#undef DrawText
	2827	#endif
	2828
	2829	#ifdef GetCharWidth
	2830	#undef GetCharWidth
	2831	#endif
	2832
	2833	#ifdef StartDoc
	2834	#undef StartDoc
	2835	#endif
	2836
	2837	#ifdef FindWindow
	2838	#undef FindWindow
	2839	#endif
	2840
	2841	#ifdef FindResource
	2842	#undef FindResource
	2843	#endif
	2844	#endif
	2845	/* __WXMSW__ */
	2846
	2847	/* --------------------------------------------------------------------------- */
	2848	/* macro to define a class without copy ctor nor assignment operator */
	2849	/* --------------------------------------------------------------------------- */
	2850
	2851	#define DECLARE_NO_COPY_CLASS(classname) \
	2852	private: \
	2853	classname(const classname&); \
	2854	classname& operator=(const classname&);
	2855
	2856	#define DECLARE_NO_ASSIGN_CLASS(classname) \
	2857	private: \
	2858	classname& operator=(const classname&);
	2859
	2860	/* --------------------------------------------------------------------------- */
	2861	/* If a manifest is being automatically generated, add common controls 6 to it */
	2862	/* --------------------------------------------------------------------------- */
	2863
	2864	#if (!defined wxUSE_NO_MANIFEST \|\| wxUSE_NO_MANIFEST == 0 ) && \
	2865	( defined _MSC_FULL_VER && _MSC_FULL_VER >= 140040130 )
	2866
	2867	#define WX_CC_MANIFEST(cpu) \
	2868	"/manifestdependency:\"type='win32' \
	2869	name='Microsoft.Windows.Common-Controls' \
	2870	version='6.0.0.0' \
	2871	processorArchitecture='"cpu"' \
	2872	publicKeyToken='6595b64144ccf1df' \
	2873	language='*'\""
	2874
	2875	#if defined _M_IX86
	2876	#pragma comment(linker, WX_CC_MANIFEST("x86"))
	2877	#elif defined _M_X64
	2878	#pragma comment(linker, WX_CC_MANIFEST("amd64"))
	2879	#elif defined _M_IA64
	2880	#pragma comment(linker, WX_CC_MANIFEST("ia64"))
	2881	#else
	2882	#pragma comment(linker, WX_CC_MANIFEST("*"))
	2883	#endif
	2884
	2885	#endif /* !wxUSE_NO_MANIFEST && _MSC_FULL_VER >= 140040130 */
	2886
	2887	#endif
	2888	/* _WX_DEFS_H_ */