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, 3)
	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	/*
	912	First check for specific compilers which have known 64 bit integer types,
	913	this avoids clashes with SIZEOF_LONG[_LONG] being defined incorrectly for
	914	e.g. MSVC builds (Python.h defines it as 8 even for MSVC).
	915
	916	Also notice that we check for "long long" before checking for 64 bit long as
	917	we still want to use "long long" and not "long" for wxLongLong_t on 64 bit
	918	architectures to be able to pass wxLongLong_t to the standard functions
	919	prototyped as taking "long long" such as strtoll().
	920	*/
	921	#if (defined(__VISUALC__) && defined(__WIN32__))
	922	#define wxLongLong_t __int64
	923	#define wxLongLongSuffix i64
	924	#define wxLongLongFmtSpec _T("I64")
	925	#elif defined(__BORLANDC__) && defined(__WIN32__) && (__BORLANDC__ >= 0x520)
	926	#define wxLongLong_t __int64
	927	#define wxLongLongSuffix i64
	928	#define wxLongLongFmtSpec _T("L")
	929	#elif (defined(__WATCOMC__) && (defined(__WIN32__) \|\| defined(__DOS__) \|\| defined(__OS2__)))
	930	#define wxLongLong_t __int64
	931	#define wxLongLongSuffix i64
	932	#define wxLongLongFmtSpec _T("L")
	933	#elif defined(__DIGITALMARS__)
	934	#define wxLongLong_t __int64
	935	#define wxLongLongSuffix LL
	936	#define wxLongLongFmtSpec _T("ll")
	937	#elif defined(__MINGW32__)
	938	#define wxLongLong_t long long
	939	#define wxLongLongSuffix ll
	940	#define wxLongLongFmtSpec _T("I64")
	941	#elif defined(__MWERKS__)
	942	#if __option(longlong)
	943	#define wxLongLong_t long long
	944	#define wxLongLongSuffix ll
	945	#define wxLongLongFmtSpec _T("ll")
	946	#else
	947	#error "The 64 bit integer support in CodeWarrior has been disabled."
	948	#error "See the documentation on the 'longlong' pragma."
	949	#endif
	950	#elif defined(__WXPALMOS__)
	951	#define wxLongLong_t int64_t
	952	#define wxLongLongSuffix ll
	953	#define wxLongLongFmtSpec _T("ll")
	954	#elif defined(__VISAGECPP__) && __IBMCPP__ >= 400
	955	#define wxLongLong_t long long
	956	#elif (defined(SIZEOF_LONG_LONG) && SIZEOF_LONG_LONG >= 8) \|\| \
	957	defined(__GNUC__) \|\| \
	958	defined(__CYGWIN__) \|\| \
	959	defined(__WXMICROWIN__) \|\| \
	960	(defined(__DJGPP__) && __DJGPP__ >= 2)
	961	#define wxLongLong_t long long
	962	#define wxLongLongSuffix ll
	963	#define wxLongLongFmtSpec _T("ll")
	964	#elif defined(SIZEOF_LONG) && (SIZEOF_LONG == 8)
	965	#define wxLongLong_t long
	966	#define wxLongLongSuffix l
	967	#define wxLongLongFmtSpec _T("l")
	968	#define wxLongLongIsLong
	969	#endif
	970
	971
	972	#ifdef wxLongLong_t
	973
	974	#ifdef __WXPALMOS__
	975	#define wxULongLong_t uint64_t
	976	#else
	977	#define wxULongLong_t unsigned wxLongLong_t
	978	#endif
	979
	980	/* these macros allow to define 64 bit constants in a portable way */
	981	#define wxLL(x) wxCONCAT(x, wxLongLongSuffix)
	982	#define wxULL(x) wxCONCAT(x, wxCONCAT(u, wxLongLongSuffix))
	983
	984	typedef wxLongLong_t wxInt64;
	985	typedef wxULongLong_t wxUint64;
	986
	987	#define wxHAS_INT64 1
	988
	989	#elif wxUSE_LONGLONG
	990	/* these macros allow to define 64 bit constants in a portable way */
	991	#define wxLL(x) wxLongLong(x)
	992	#define wxULL(x) wxULongLong(x)
	993
	994	#define wxInt64 wxLongLong
	995	#define wxUint64 wxULongLong
	996
	997	#define wxHAS_INT64 1
	998
	999	#else /* !wxUSE_LONGLONG */
	1000
	1001	#define wxHAS_INT64 0
	1002
	1003	#endif
	1004
	1005
	1006	/* Make sure ssize_t is defined (a signed type the same size as size_t) */
	1007	/* HAVE_SSIZE_T should be defined for compiliers that already have it */
	1008	#ifdef __MINGW32__
	1009	#if defined(_SSIZE_T_) && !defined(HAVE_SSIZE_T)
	1010	#define HAVE_SSIZE_T
	1011	#endif
	1012	#endif
	1013	#if defined(__PALMOS__) && !defined(HAVE_SSIZE_T)
	1014	#define HAVE_SSIZE_T
	1015	#endif
	1016	#if wxCHECK_WATCOM_VERSION(1,4)
	1017	#define HAVE_SSIZE_T
	1018	#endif
	1019	#ifndef HAVE_SSIZE_T
	1020	#if SIZEOF_SIZE_T == 4
	1021	typedef wxInt32 ssize_t;
	1022	#elif SIZEOF_SIZE_T == 8
	1023	typedef wxInt64 ssize_t;
	1024	#else
	1025	#error "error defining ssize_t, size_t is not 4 or 8 bytes"
	1026	#endif
	1027	#endif
	1028
	1029
	1030	/* base floating point types */
	1031	/* wxFloat32: 32 bit IEEE float ( 1 sign, 8 exponent bits, 23 fraction bits */
	1032	/* wxFloat64: 64 bit IEEE float ( 1 sign, 11 exponent bits, 52 fraction bits */
	1033	/* wxDouble: native fastest representation that has at least wxFloat64 */
	1034	/* precision, so use the IEEE types for storage, and this for */
	1035	/* calculations */
	1036
	1037	typedef float wxFloat32;
	1038	#if (defined( __WXMAC__ ) \|\| defined(__WXCOCOA__)) && defined (__MWERKS__)
	1039	typedef short double wxFloat64;
	1040	#else
	1041	typedef double wxFloat64;
	1042	#endif
	1043
	1044	#if defined( __WXMAC__ ) && !defined( __POWERPC__ )
	1045	typedef long double wxDouble;
	1046	#else
	1047	typedef double wxDouble;
	1048	#endif
	1049
	1050	/*
	1051	Some (non standard) compilers typedef wchar_t as an existing type instead
	1052	of treating it as a real fundamental type, set wxWCHAR_T_IS_REAL_TYPE to 0
	1053	for them and to 1 for all the others.
	1054	*/
	1055	#if wxUSE_WCHAR_T
	1056	/*
	1057	VC++ typedefs wchar_t as unsigned short by default, that is unless
	1058	/Za or /Zc:wchar_t option is used in which case _WCHAR_T_DEFINED is
	1059	defined.
	1060	*/
	1061	# if defined(__VISUALC__) && !defined(_NATIVE_WCHAR_T_DEFINED)
	1062	# define wxWCHAR_T_IS_REAL_TYPE 0
	1063	# else /* compiler having standard-conforming wchar_t */
	1064	# define wxWCHAR_T_IS_REAL_TYPE 1
	1065	# endif
	1066	#endif /* wxUSE_WCHAR_T */
	1067
	1068	/* ---------------------------------------------------------------------------- */
	1069	/* byte ordering related definition and macros */
	1070	/* ---------------------------------------------------------------------------- */
	1071
	1072	/* byte sex */
	1073
	1074	#define wxBIG_ENDIAN 4321
	1075	#define wxLITTLE_ENDIAN 1234
	1076	#define wxPDP_ENDIAN 3412
	1077
	1078	#ifdef WORDS_BIGENDIAN
	1079	#define wxBYTE_ORDER wxBIG_ENDIAN
	1080	#else
	1081	#define wxBYTE_ORDER wxLITTLE_ENDIAN
	1082	#endif
	1083
	1084	/* byte swapping */
	1085
	1086	#if defined (__MWERKS__) && ( (__MWERKS__ < 0x0900) \|\| macintosh )
	1087	/* assembler versions for these */
	1088	#ifdef __POWERPC__
	1089	inline wxUint16 wxUINT16_SWAP_ALWAYS( wxUint16 i )
	1090	{return (__lhbrx( &i , 0 ) );}
	1091	inline wxInt16 wxINT16_SWAP_ALWAYS( wxInt16 i )
	1092	{return (__lhbrx( &i , 0 ) );}
	1093	inline wxUint32 wxUINT32_SWAP_ALWAYS( wxUint32 i )
	1094	{return (__lwbrx( &i , 0 ) );}
	1095	inline wxInt32 wxINT32_SWAP_ALWAYS( wxInt32 i )
	1096	{return (__lwbrx( &i , 0 ) );}
	1097	#else
	1098	#pragma parameter __D0 wxUINT16_SWAP_ALWAYS(__D0)
	1099	pascal wxUint16 wxUINT16_SWAP_ALWAYS(wxUint16 value)
	1100	= { 0xE158 };
	1101
	1102	#pragma parameter __D0 wxINT16_SWAP_ALWAYS(__D0)
	1103	pascal wxInt16 wxINT16_SWAP_ALWAYS(wxInt16 value)
	1104	= { 0xE158 };
	1105
	1106	#pragma parameter __D0 wxUINT32_SWAP_ALWAYS (__D0)
	1107	pascal wxUint32 wxUINT32_SWAP_ALWAYS(wxUint32 value)
	1108	= { 0xE158, 0x4840, 0xE158 };
	1109
	1110	#pragma parameter __D0 wxINT32_SWAP_ALWAYS (__D0)
	1111	pascal wxInt32 wxINT32_SWAP_ALWAYS(wxInt32 value)
	1112	= { 0xE158, 0x4840, 0xE158 };
	1113
	1114	#endif
	1115	#else /* !MWERKS */
	1116	#define wxUINT16_SWAP_ALWAYS(val) \
	1117	((wxUint16) ( \
	1118	(((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) \| \
	1119	(((wxUint16) (val) & (wxUint16) 0xff00U) >> 8)))
	1120
	1121	#define wxINT16_SWAP_ALWAYS(val) \
	1122	((wxInt16) ( \
	1123	(((wxUint16) (val) & (wxUint16) 0x00ffU) << 8) \| \
	1124	(((wxUint16) (val) & (wxUint16) 0xff00U) >> 8)))
	1125
	1126	#define wxUINT32_SWAP_ALWAYS(val) \
	1127	((wxUint32) ( \
	1128	(((wxUint32) (val) & (wxUint32) 0x000000ffU) << 24) \| \
	1129	(((wxUint32) (val) & (wxUint32) 0x0000ff00U) << 8) \| \
	1130	(((wxUint32) (val) & (wxUint32) 0x00ff0000U) >> 8) \| \
	1131	(((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
	1132
	1133	#define wxINT32_SWAP_ALWAYS(val) \
	1134	((wxInt32) ( \
	1135	(((wxUint32) (val) & (wxUint32) 0x000000ffU) << 24) \| \
	1136	(((wxUint32) (val) & (wxUint32) 0x0000ff00U) << 8) \| \
	1137	(((wxUint32) (val) & (wxUint32) 0x00ff0000U) >> 8) \| \
	1138	(((wxUint32) (val) & (wxUint32) 0xff000000U) >> 24)))
	1139	#endif
	1140	/* machine specific byte swapping */
	1141
	1142	#ifdef wxLongLong_t
	1143	#define wxUINT64_SWAP_ALWAYS(val) \
	1144	((wxUint64) ( \
	1145	(((wxUint64) (val) & (wxUint64) wxULL(0x00000000000000ff)) << 56) \| \
	1146	(((wxUint64) (val) & (wxUint64) wxULL(0x000000000000ff00)) << 40) \| \
	1147	(((wxUint64) (val) & (wxUint64) wxULL(0x0000000000ff0000)) << 24) \| \
	1148	(((wxUint64) (val) & (wxUint64) wxULL(0x00000000ff000000)) << 8) \| \
	1149	(((wxUint64) (val) & (wxUint64) wxULL(0x000000ff00000000)) >> 8) \| \
	1150	(((wxUint64) (val) & (wxUint64) wxULL(0x0000ff0000000000)) >> 24) \| \
	1151	(((wxUint64) (val) & (wxUint64) wxULL(0x00ff000000000000)) >> 40) \| \
	1152	(((wxUint64) (val) & (wxUint64) wxULL(0xff00000000000000)) >> 56)))
	1153
	1154	#define wxINT64_SWAP_ALWAYS(val) \
	1155	((wxInt64) ( \
	1156	(((wxUint64) (val) & (wxUint64) wxULL(0x00000000000000ff)) << 56) \| \
	1157	(((wxUint64) (val) & (wxUint64) wxULL(0x000000000000ff00)) << 40) \| \
	1158	(((wxUint64) (val) & (wxUint64) wxULL(0x0000000000ff0000)) << 24) \| \
	1159	(((wxUint64) (val) & (wxUint64) wxULL(0x00000000ff000000)) << 8) \| \
	1160	(((wxUint64) (val) & (wxUint64) wxULL(0x000000ff00000000)) >> 8) \| \
	1161	(((wxUint64) (val) & (wxUint64) wxULL(0x0000ff0000000000)) >> 24) \| \
	1162	(((wxUint64) (val) & (wxUint64) wxULL(0x00ff000000000000)) >> 40) \| \
	1163	(((wxUint64) (val) & (wxUint64) wxULL(0xff00000000000000)) >> 56)))
	1164	#elif wxUSE_LONGLONG /* !wxLongLong_t */
	1165	#define wxUINT64_SWAP_ALWAYS(val) \
	1166	((wxUint64) ( \
	1167	((wxULongLong(val) & wxULongLong(0L, 0x000000ffU)) << 56) \| \
	1168	((wxULongLong(val) & wxULongLong(0L, 0x0000ff00U)) << 40) \| \
	1169	((wxULongLong(val) & wxULongLong(0L, 0x00ff0000U)) << 24) \| \
	1170	((wxULongLong(val) & wxULongLong(0L, 0xff000000U)) << 8) \| \
	1171	((wxULongLong(val) & wxULongLong(0x000000ffL, 0U)) >> 8) \| \
	1172	((wxULongLong(val) & wxULongLong(0x0000ff00L, 0U)) >> 24) \| \
	1173	((wxULongLong(val) & wxULongLong(0x00ff0000L, 0U)) >> 40) \| \
	1174	((wxULongLong(val) & wxULongLong(0xff000000L, 0U)) >> 56)))
	1175
	1176	#define wxINT64_SWAP_ALWAYS(val) \
	1177	((wxInt64) ( \
	1178	((wxLongLong(val) & wxLongLong(0L, 0x000000ffU)) << 56) \| \
	1179	((wxLongLong(val) & wxLongLong(0L, 0x0000ff00U)) << 40) \| \
	1180	((wxLongLong(val) & wxLongLong(0L, 0x00ff0000U)) << 24) \| \
	1181	((wxLongLong(val) & wxLongLong(0L, 0xff000000U)) << 8) \| \
	1182	((wxLongLong(val) & wxLongLong(0x000000ffL, 0U)) >> 8) \| \
	1183	((wxLongLong(val) & wxLongLong(0x0000ff00L, 0U)) >> 24) \| \
	1184	((wxLongLong(val) & wxLongLong(0x00ff0000L, 0U)) >> 40) \| \
	1185	((wxLongLong(val) & wxLongLong(0xff000000L, 0U)) >> 56)))
	1186	#endif /* wxLongLong_t/!wxLongLong_t */
	1187
	1188	#ifdef WORDS_BIGENDIAN
	1189	#define wxUINT16_SWAP_ON_BE(val) wxUINT16_SWAP_ALWAYS(val)
	1190	#define wxINT16_SWAP_ON_BE(val) wxINT16_SWAP_ALWAYS(val)
	1191	#define wxUINT16_SWAP_ON_LE(val) (val)
	1192	#define wxINT16_SWAP_ON_LE(val) (val)
	1193	#define wxUINT32_SWAP_ON_BE(val) wxUINT32_SWAP_ALWAYS(val)
	1194	#define wxINT32_SWAP_ON_BE(val) wxINT32_SWAP_ALWAYS(val)
	1195	#define wxUINT32_SWAP_ON_LE(val) (val)
	1196	#define wxINT32_SWAP_ON_LE(val) (val)
	1197	#if wxHAS_INT64
	1198	#define wxUINT64_SWAP_ON_BE(val) wxUINT64_SWAP_ALWAYS(val)
	1199	#define wxUINT64_SWAP_ON_LE(val) (val)
	1200	#endif
	1201	#else
	1202	#define wxUINT16_SWAP_ON_LE(val) wxUINT16_SWAP_ALWAYS(val)
	1203	#define wxINT16_SWAP_ON_LE(val) wxINT16_SWAP_ALWAYS(val)
	1204	#define wxUINT16_SWAP_ON_BE(val) (val)
	1205	#define wxINT16_SWAP_ON_BE(val) (val)
	1206	#define wxUINT32_SWAP_ON_LE(val) wxUINT32_SWAP_ALWAYS(val)
	1207	#define wxINT32_SWAP_ON_LE(val) wxINT32_SWAP_ALWAYS(val)
	1208	#define wxUINT32_SWAP_ON_BE(val) (val)
	1209	#define wxINT32_SWAP_ON_BE(val) (val)
	1210	#if wxHAS_INT64
	1211	#define wxUINT64_SWAP_ON_LE(val) wxUINT64_SWAP_ALWAYS(val)
	1212	#define wxUINT64_SWAP_ON_BE(val) (val)
	1213	#endif
	1214	#endif
	1215
	1216	/* ---------------------------------------------------------------------------- */
	1217	/* Geometric flags */
	1218	/* ---------------------------------------------------------------------------- */
	1219
	1220	enum wxGeometryCentre
	1221	{
	1222	wxCENTRE = 0x0001,
	1223	wxCENTER = wxCENTRE
	1224	};
	1225
	1226	/* centering into frame rather than screen (obsolete) */
	1227	#define wxCENTER_FRAME 0x0000
	1228	/* centre on screen rather than parent */
	1229	#define wxCENTRE_ON_SCREEN 0x0002
	1230	#define wxCENTER_ON_SCREEN wxCENTRE_ON_SCREEN
	1231
	1232	enum wxOrientation
	1233	{
	1234	/* don't change the values of these elements, they are used elsewhere */
	1235	wxHORIZONTAL = 0x0004,
	1236	wxVERTICAL = 0x0008,
	1237
	1238	wxBOTH = wxVERTICAL \| wxHORIZONTAL
	1239	};
	1240
	1241	enum wxDirection
	1242	{
	1243	wxLEFT = 0x0010,
	1244	wxRIGHT = 0x0020,
	1245	wxUP = 0x0040,
	1246	wxDOWN = 0x0080,
	1247
	1248	wxTOP = wxUP,
	1249	wxBOTTOM = wxDOWN,
	1250
	1251	wxNORTH = wxUP,
	1252	wxSOUTH = wxDOWN,
	1253	wxWEST = wxLEFT,
	1254	wxEAST = wxRIGHT,
	1255
	1256	wxALL = (wxUP \| wxDOWN \| wxRIGHT \| wxLEFT)
	1257	};
	1258
	1259	enum wxAlignment
	1260	{
	1261	wxALIGN_NOT = 0x0000,
	1262	wxALIGN_CENTER_HORIZONTAL = 0x0100,
	1263	wxALIGN_CENTRE_HORIZONTAL = wxALIGN_CENTER_HORIZONTAL,
	1264	wxALIGN_LEFT = wxALIGN_NOT,
	1265	wxALIGN_TOP = wxALIGN_NOT,
	1266	wxALIGN_RIGHT = 0x0200,
	1267	wxALIGN_BOTTOM = 0x0400,
	1268	wxALIGN_CENTER_VERTICAL = 0x0800,
	1269	wxALIGN_CENTRE_VERTICAL = wxALIGN_CENTER_VERTICAL,
	1270
	1271	wxALIGN_CENTER = (wxALIGN_CENTER_HORIZONTAL \| wxALIGN_CENTER_VERTICAL),
	1272	wxALIGN_CENTRE = wxALIGN_CENTER,
	1273
	1274	/* a mask to extract alignment from the combination of flags */
	1275	wxALIGN_MASK = 0x0f00
	1276	};
	1277
	1278	enum wxStretch
	1279	{
	1280	wxSTRETCH_NOT = 0x0000,
	1281	wxSHRINK = 0x1000,
	1282	wxGROW = 0x2000,
	1283	wxEXPAND = wxGROW,
	1284	wxSHAPED = 0x4000,
	1285	wxFIXED_MINSIZE = 0x8000,
	1286	wxTILE = 0xc000,
	1287
	1288	/* for compatibility only, default now, don't use explicitly any more */
	1289	#if WXWIN_COMPATIBILITY_2_4
	1290	wxADJUST_MINSIZE = 0x00100000
	1291	#else
	1292	wxADJUST_MINSIZE = 0
	1293	#endif
	1294	};
	1295
	1296	/* border flags: the values are chosen for backwards compatibility */
	1297	enum wxBorder
	1298	{
	1299	/* this is different from wxBORDER_NONE as by default the controls do have */
	1300	/* border */
	1301	wxBORDER_DEFAULT = 0,
	1302
	1303	wxBORDER_NONE = 0x00200000,
	1304	wxBORDER_STATIC = 0x01000000,
	1305	wxBORDER_SIMPLE = 0x02000000,
	1306	wxBORDER_RAISED = 0x04000000,
	1307	wxBORDER_SUNKEN = 0x08000000,
	1308	wxBORDER_DOUBLE = 0x10000000,
	1309
	1310	/* a mask to extract border style from the combination of flags */
	1311	wxBORDER_MASK = 0x1f200000
	1312	};
	1313
	1314	/* This makes it easier to specify a 'normal' border for a control */
	1315	#if defined(__SMARTPHONE__) \|\| defined(__POCKETPC__)
	1316	#define wxDEFAULT_CONTROL_BORDER wxBORDER_SIMPLE
	1317	#else
	1318	#define wxDEFAULT_CONTROL_BORDER wxBORDER_SUNKEN
	1319	#endif
	1320
	1321	/* ---------------------------------------------------------------------------- */
	1322	/* Window style flags */
	1323	/* ---------------------------------------------------------------------------- */
	1324
	1325	/*
	1326	* Values are chosen so they can be \|'ed in a bit list.
	1327	* Some styles are used across more than one group,
	1328	* so the values mustn't clash with others in the group.
	1329	* Otherwise, numbers can be reused across groups.
	1330	*
	1331	* From version 1.66:
	1332	* Window (cross-group) styles now take up the first half
	1333	* of the flag, and control-specific styles the
	1334	* second half.
	1335	*
	1336	*/
	1337
	1338	/*
	1339	* Window (Frame/dialog/subwindow/panel item) style flags
	1340	*/
	1341	#define wxVSCROLL 0x80000000
	1342	#define wxHSCROLL 0x40000000
	1343	#define wxCAPTION 0x20000000
	1344
	1345	/* New styles (border styles are now in their own enum) */
	1346	#define wxDOUBLE_BORDER wxBORDER_DOUBLE
	1347	#define wxSUNKEN_BORDER wxBORDER_SUNKEN
	1348	#define wxRAISED_BORDER wxBORDER_RAISED
	1349	#define wxBORDER wxBORDER_SIMPLE
	1350	#define wxSIMPLE_BORDER wxBORDER_SIMPLE
	1351	#define wxSTATIC_BORDER wxBORDER_STATIC
	1352	#define wxNO_BORDER wxBORDER_NONE
	1353
	1354	/* wxALWAYS_SHOW_SB: instead of hiding the scrollbar when it is not needed, */
	1355	/* disable it - but still show (see also wxLB_ALWAYS_SB style) */
	1356	/* */
	1357	/* NB: as this style is only supported by wxUniversal and wxMSW so far */
	1358	#define wxALWAYS_SHOW_SB 0x00800000
	1359
	1360	/* Clip children when painting, which reduces flicker in e.g. frames and */
	1361	/* splitter windows, but can't be used in a panel where a static box must be */
	1362	/* 'transparent' (panel paints the background for it) */
	1363	#define wxCLIP_CHILDREN 0x00400000
	1364
	1365	/* Note we're reusing the wxCAPTION style because we won't need captions */
	1366	/* for subwindows/controls */
	1367	#define wxCLIP_SIBLINGS 0x20000000
	1368
	1369	#define wxTRANSPARENT_WINDOW 0x00100000
	1370
	1371	/* Add this style to a panel to get tab traversal working outside of dialogs */
	1372	/* (on by default for wxPanel, wxDialog, wxScrolledWindow) */
	1373	#define wxTAB_TRAVERSAL 0x00080000
	1374
	1375	/* Add this style if the control wants to get all keyboard messages (under */
	1376	/* Windows, it won't normally get the dialog navigation key events) */
	1377	#define wxWANTS_CHARS 0x00040000
	1378
	1379	/* Make window retained (Motif only, see src/generic/scrolwing.cpp)
	1380	* This is non-zero only under wxMotif, to avoid a clash with wxPOPUP_WINDOW
	1381	* on other platforms
	1382	*/
	1383
	1384	#ifdef __WXMOTIF__
	1385	#define wxRETAINED 0x00020000
	1386	#else
	1387	#define wxRETAINED 0x00000000
	1388	#endif
	1389	#define wxBACKINGSTORE wxRETAINED
	1390
	1391	/* set this flag to create a special popup window: it will be always shown on */
	1392	/* top of other windows, will capture the mouse and will be dismissed when the */
	1393	/* mouse is clicked outside of it or if it loses focus in any other way */
	1394	#define wxPOPUP_WINDOW 0x00020000
	1395
	1396	/* force a full repaint when the window is resized (instead of repainting just */
	1397	/* the invalidated area) */
	1398	#define wxFULL_REPAINT_ON_RESIZE 0x00010000
	1399
	1400	/* obsolete: now this is the default behaviour */
	1401	/* */
	1402	/* don't invalidate the whole window (resulting in a PAINT event) when the */
	1403	/* window is resized (currently, makes sense for wxMSW only) */
	1404	#define wxNO_FULL_REPAINT_ON_RESIZE 0
	1405
	1406	/* A mask which can be used to filter (out) all wxWindow-specific styles.
	1407	*/
	1408	#define wxWINDOW_STYLE_MASK \
	1409	(wxVSCROLL\|wxHSCROLL\|wxBORDER_MASK\|wxALWAYS_SHOW_SB\|wxCLIP_CHILDREN\| \
	1410	wxCLIP_SIBLINGS\|wxTRANSPARENT_WINDOW\|wxTAB_TRAVERSAL\|wxWANTS_CHARS\| \
	1411	wxRETAINED\|wxPOPUP_WINDOW\|wxFULL_REPAINT_ON_RESIZE)
	1412
	1413	/*
	1414	* Extra window style flags (use wxWS_EX prefix to make it clear that they
	1415	* should be passed to wxWindow::SetExtraStyle(), not SetWindowStyle())
	1416	*/
	1417
	1418	/* by default, TransferDataTo/FromWindow() only work on direct children of the */
	1419	/* window (compatible behaviour), set this flag to make them recursively */
	1420	/* descend into all subwindows */
	1421	#define wxWS_EX_VALIDATE_RECURSIVELY 0x00000001
	1422
	1423	/* wxCommandEvents and the objects of the derived classes are forwarded to the */
	1424	/* parent window and so on recursively by default. Using this flag for the */
	1425	/* given window allows to block this propagation at this window, i.e. prevent */
	1426	/* the events from being propagated further upwards. The dialogs have this */
	1427	/* flag on by default. */
	1428	#define wxWS_EX_BLOCK_EVENTS 0x00000002
	1429
	1430	/* don't use this window as an implicit parent for the other windows: this must */
	1431	/* be used with transient windows as otherwise there is the risk of creating a */
	1432	/* dialog/frame with this window as a parent which would lead to a crash if the */
	1433	/* parent is destroyed before the child */
	1434	#define wxWS_EX_TRANSIENT 0x00000004
	1435
	1436	/* don't paint the window background, we'll assume it will */
	1437	/* be done by a theming engine. This is not yet used but could */
	1438	/* possibly be made to work in the future, at least on Windows */
	1439	#define wxWS_EX_THEMED_BACKGROUND 0x00000008
	1440
	1441	/* this window should always process idle events */
	1442	#define wxWS_EX_PROCESS_IDLE 0x00000010
	1443
	1444	/* this window should always process UI update events */
	1445	#define wxWS_EX_PROCESS_UI_UPDATES 0x00000020
	1446
	1447	/* Draw the window in a metal theme on Mac */
	1448	#define wxFRAME_EX_METAL 0x00000040
	1449	#define wxDIALOG_EX_METAL 0x00000040
	1450
	1451	/* Use this style to add a context-sensitive help to the window (currently for */
	1452	/* Win32 only and it doesn't work if wxMINIMIZE_BOX or wxMAXIMIZE_BOX are used) */
	1453	#define wxWS_EX_CONTEXTHELP 0x00000080
	1454
	1455	/* synonyms for wxWS_EX_CONTEXTHELP for compatibility */
	1456	#define wxFRAME_EX_CONTEXTHELP wxWS_EX_CONTEXTHELP
	1457	#define wxDIALOG_EX_CONTEXTHELP wxWS_EX_CONTEXTHELP
	1458
	1459	/* Create a window which is attachable to another top level window */
	1460	#define wxFRAME_DRAWER 0x0020
	1461
	1462	/*
	1463	* MDI parent frame style flags
	1464	* Can overlap with some of the above.
	1465	*/
	1466
	1467	#define wxFRAME_NO_WINDOW_MENU 0x0100
	1468
	1469	/*
	1470	* wxMenuBar style flags
	1471	*/
	1472	/* use native docking */
	1473	#define wxMB_DOCKABLE 0x0001
	1474
	1475	/*
	1476	* wxMenu style flags
	1477	*/
	1478	#define wxMENU_TEAROFF 0x0001
	1479
	1480	/*
	1481	* Apply to all panel items
	1482	*/
	1483	#define wxCOLOURED 0x0800
	1484	#define wxFIXED_LENGTH 0x0400
	1485
	1486	/*
	1487	* Styles for wxListBox
	1488	*/
	1489	#define wxLB_SORT 0x0010
	1490	#define wxLB_SINGLE 0x0020
	1491	#define wxLB_MULTIPLE 0x0040
	1492	#define wxLB_EXTENDED 0x0080
	1493	/* wxLB_OWNERDRAW is Windows-only */
	1494	#define wxLB_OWNERDRAW 0x0100
	1495	#define wxLB_NEEDED_SB 0x0200
	1496	#define wxLB_ALWAYS_SB 0x0400
	1497	#define wxLB_HSCROLL wxHSCROLL
	1498	/* always show an entire number of rows */
	1499	#define wxLB_INT_HEIGHT 0x0800
	1500
	1501	#if WXWIN_COMPATIBILITY_2_6
	1502	/* deprecated synonyms */
	1503	#define wxPROCESS_ENTER 0x0400 /* wxTE_PROCESS_ENTER */
	1504	#define wxPASSWORD 0x0800 /* wxTE_PASSWORD */
	1505	#endif
	1506
	1507	/*
	1508	* wxComboBox style flags
	1509	*/
	1510	#define wxCB_SIMPLE 0x0004
	1511	#define wxCB_SORT 0x0008
	1512	#define wxCB_READONLY 0x0010
	1513	#define wxCB_DROPDOWN 0x0020
	1514
	1515	/*
	1516	* wxRadioBox style flags
	1517	*/
	1518	/* should we number the items from left to right or from top to bottom in a 2d */
	1519	/* radiobox? */
	1520	#define wxRA_LEFTTORIGHT 0x0001
	1521	#define wxRA_TOPTOBOTTOM 0x0002
	1522
	1523	/* New, more intuitive names to specify majorDim argument */
	1524	#define wxRA_SPECIFY_COLS wxHORIZONTAL
	1525	#define wxRA_SPECIFY_ROWS wxVERTICAL
	1526
	1527	/* Old names for compatibility */
	1528	#define wxRA_HORIZONTAL wxHORIZONTAL
	1529	#define wxRA_VERTICAL wxVERTICAL
	1530	#define wxRA_USE_CHECKBOX 0x0010 /* alternative native subcontrols (wxPalmOS) */
	1531
	1532	/*
	1533	* wxRadioButton style flag
	1534	*/
	1535	#define wxRB_GROUP 0x0004
	1536	#define wxRB_SINGLE 0x0008
	1537	#define wxRB_USE_CHECKBOX 0x0010 /* alternative native control (wxPalmOS) */
	1538
	1539	/*
	1540	* wxScrollBar flags
	1541	*/
	1542	#define wxSB_HORIZONTAL wxHORIZONTAL
	1543	#define wxSB_VERTICAL wxVERTICAL
	1544
	1545	/*
	1546	* wxSpinButton flags.
	1547	* Note that a wxSpinCtrl is sometimes defined as
	1548	* a wxTextCtrl, and so the flags must be different
	1549	* from wxTextCtrl's.
	1550	*/
	1551	#define wxSP_HORIZONTAL wxHORIZONTAL /* 4 */
	1552	#define wxSP_VERTICAL wxVERTICAL /* 8 */
	1553	#define wxSP_ARROW_KEYS 0x1000
	1554	#define wxSP_WRAP 0x2000
	1555
	1556	/*
	1557	* wxTabCtrl flags
	1558	*/
	1559	#define wxTC_RIGHTJUSTIFY 0x0010
	1560	#define wxTC_FIXEDWIDTH 0x0020
	1561	#define wxTC_TOP 0x0000 /* default */
	1562	#define wxTC_LEFT 0x0020
	1563	#define wxTC_RIGHT 0x0040
	1564	#define wxTC_BOTTOM 0x0080
	1565	#define wxTC_MULTILINE 0x0200 /* == wxNB_MULTILINE */
	1566	#define wxTC_OWNERDRAW 0x0400
	1567
	1568	/*
	1569	* wxStatusBar95 flags
	1570	*/
	1571	#define wxST_SIZEGRIP 0x0010
	1572
	1573	/*
	1574	* wxStaticText flags
	1575	*/
	1576	#define wxST_NO_AUTORESIZE 0x0001
	1577	#define wxST_DOTS_MIDDLE 0x0002
	1578	#define wxST_DOTS_END 0x0004
	1579
	1580	/*
	1581	* wxStaticBitmap flags
	1582	*/
	1583	#define wxBI_EXPAND wxEXPAND
	1584
	1585	/*
	1586	* wxStaticLine flags
	1587	*/
	1588	#define wxLI_HORIZONTAL wxHORIZONTAL
	1589	#define wxLI_VERTICAL wxVERTICAL
	1590
	1591
	1592	/*
	1593	* extended dialog specifiers. these values are stored in a different
	1594	* flag and thus do not overlap with other style flags. note that these
	1595	* values do not correspond to the return values of the dialogs (for
	1596	* those values, look at the wxID_XXX defines).
	1597	*/
	1598
	1599	/* wxCENTRE already defined as 0x00000001 */
	1600	#define wxYES 0x00000002
	1601	#define wxOK 0x00000004
	1602	#define wxNO 0x00000008
	1603	#define wxYES_NO (wxYES \| wxNO)
	1604	#define wxCANCEL 0x00000010
	1605
	1606	#define wxYES_DEFAULT 0x00000000 /* has no effect (default) */
	1607	#define wxNO_DEFAULT 0x00000080
	1608
	1609	#define wxICON_EXCLAMATION 0x00000100
	1610	#define wxICON_HAND 0x00000200
	1611	#define wxICON_WARNING wxICON_EXCLAMATION
	1612	#define wxICON_ERROR wxICON_HAND
	1613	#define wxICON_QUESTION 0x00000400
	1614	#define wxICON_INFORMATION 0x00000800
	1615	#define wxICON_STOP wxICON_HAND
	1616	#define wxICON_ASTERISK wxICON_INFORMATION
	1617	#define wxICON_MASK (0x00000100\|0x00000200\|0x00000400\|0x00000800)
	1618
	1619	#define wxFORWARD 0x00001000
	1620	#define wxBACKWARD 0x00002000
	1621	#define wxRESET 0x00004000
	1622	#define wxHELP 0x00008000
	1623	#define wxMORE 0x00010000
	1624	#define wxSETUP 0x00020000
	1625
	1626	/*
	1627	* Background styles. See wxWindow::SetBackgroundStyle
	1628	*/
	1629
	1630	enum wxBackgroundStyle
	1631	{
	1632	wxBG_STYLE_SYSTEM,
	1633	wxBG_STYLE_COLOUR,
	1634	wxBG_STYLE_CUSTOM
	1635	};
	1636
	1637	/* ---------------------------------------------------------------------------- */
	1638	/* standard IDs */
	1639	/* ---------------------------------------------------------------------------- */
	1640
	1641	/* Standard menu IDs */
	1642	enum
	1643	{
	1644	/* no id matches this one when compared to it */
	1645	wxID_NONE = -3,
	1646
	1647	/* id for a separator line in the menu (invalid for normal item) */
	1648	wxID_SEPARATOR = -2,
	1649
	1650	/* any id: means that we don't care about the id, whether when installing
	1651	* an event handler or when creating a new window */
	1652	wxID_ANY = -1,
	1653
	1654
	1655	/* all predefined ids are between wxID_LOWEST and wxID_HIGHEST */
	1656	wxID_LOWEST = 4999,
	1657
	1658	wxID_OPEN,
	1659	wxID_CLOSE,
	1660	wxID_NEW,
	1661	wxID_SAVE,
	1662	wxID_SAVEAS,
	1663	wxID_REVERT,
	1664	wxID_EXIT,
	1665	wxID_UNDO,
	1666	wxID_REDO,
	1667	wxID_HELP,
	1668	wxID_PRINT,
	1669	wxID_PRINT_SETUP,
	1670	wxID_PAGE_SETUP,
	1671	wxID_PREVIEW,
	1672	wxID_ABOUT,
	1673	wxID_HELP_CONTENTS,
	1674	wxID_HELP_INDEX,
	1675	wxID_HELP_SEARCH,
	1676	wxID_HELP_COMMANDS,
	1677	wxID_HELP_PROCEDURES,
	1678	wxID_HELP_CONTEXT,
	1679	wxID_CLOSE_ALL,
	1680	wxID_PREFERENCES,
	1681
	1682	wxID_EDIT = 5030,
	1683	wxID_CUT,
	1684	wxID_COPY,
	1685	wxID_PASTE,
	1686	wxID_CLEAR,
	1687	wxID_FIND,
	1688	wxID_DUPLICATE,
	1689	wxID_SELECTALL,
	1690	wxID_DELETE,
	1691	wxID_REPLACE,
	1692	wxID_REPLACE_ALL,
	1693	wxID_PROPERTIES,
	1694
	1695	wxID_VIEW_DETAILS,
	1696	wxID_VIEW_LARGEICONS,
	1697	wxID_VIEW_SMALLICONS,
	1698	wxID_VIEW_LIST,
	1699	wxID_VIEW_SORTDATE,
	1700	wxID_VIEW_SORTNAME,
	1701	wxID_VIEW_SORTSIZE,
	1702	wxID_VIEW_SORTTYPE,
	1703
	1704	wxID_FILE = 5050,
	1705	wxID_FILE1,
	1706	wxID_FILE2,
	1707	wxID_FILE3,
	1708	wxID_FILE4,
	1709	wxID_FILE5,
	1710	wxID_FILE6,
	1711	wxID_FILE7,
	1712	wxID_FILE8,
	1713	wxID_FILE9,
	1714
	1715	/* Standard button and menu IDs */
	1716	wxID_OK = 5100,
	1717	wxID_CANCEL,
	1718	wxID_APPLY,
	1719	wxID_YES,
	1720	wxID_NO,
	1721	wxID_STATIC,
	1722	wxID_FORWARD,
	1723	wxID_BACKWARD,
	1724	wxID_DEFAULT,
	1725	wxID_MORE,
	1726	wxID_SETUP,
	1727	wxID_RESET,
	1728	wxID_CONTEXT_HELP,
	1729	wxID_YESTOALL,
	1730	wxID_NOTOALL,
	1731	wxID_ABORT,
	1732	wxID_RETRY,
	1733	wxID_IGNORE,
	1734	wxID_ADD,
	1735	wxID_REMOVE,
	1736
	1737	wxID_UP,
	1738	wxID_DOWN,
	1739	wxID_HOME,
	1740	wxID_REFRESH,
	1741	wxID_STOP,
	1742	wxID_INDEX,
	1743
	1744	wxID_BOLD,
	1745	wxID_ITALIC,
	1746	wxID_JUSTIFY_CENTER,
	1747	wxID_JUSTIFY_FILL,
	1748	wxID_JUSTIFY_RIGHT,
	1749	wxID_JUSTIFY_LEFT,
	1750	wxID_UNDERLINE,
	1751	wxID_INDENT,
	1752	wxID_UNINDENT,
	1753	wxID_ZOOM_100,
	1754	wxID_ZOOM_FIT,
	1755	wxID_ZOOM_IN,
	1756	wxID_ZOOM_OUT,
	1757	wxID_UNDELETE,
	1758	wxID_REVERT_TO_SAVED,
	1759
	1760	/* System menu IDs (used by wxUniv): */
	1761	wxID_SYSTEM_MENU = 5200,
	1762	wxID_CLOSE_FRAME,
	1763	wxID_MOVE_FRAME,
	1764	wxID_RESIZE_FRAME,
	1765	wxID_MAXIMIZE_FRAME,
	1766	wxID_ICONIZE_FRAME,
	1767	wxID_RESTORE_FRAME,
	1768
	1769	/* IDs used by generic file dialog (13 consecutive starting from this value) */
	1770	wxID_FILEDLGG = 5900,
	1771
	1772	wxID_HIGHEST = 5999
	1773	};
	1774
	1775	/* ---------------------------------------------------------------------------- */
	1776	/* other constants */
	1777	/* ---------------------------------------------------------------------------- */
	1778
	1779	/* menu and toolbar item kinds */
	1780	enum wxItemKind
	1781	{
	1782	wxITEM_SEPARATOR = -1,
	1783	wxITEM_NORMAL,
	1784	wxITEM_CHECK,
	1785	wxITEM_RADIO,
	1786	wxITEM_MAX
	1787	};
	1788
	1789	/* hit test results */
	1790	enum wxHitTest
	1791	{
	1792	wxHT_NOWHERE,
	1793
	1794	/* scrollbar */
	1795	wxHT_SCROLLBAR_FIRST = wxHT_NOWHERE,
	1796	wxHT_SCROLLBAR_ARROW_LINE_1, /* left or upper arrow to scroll by line */
	1797	wxHT_SCROLLBAR_ARROW_LINE_2, /* right or down */
	1798	wxHT_SCROLLBAR_ARROW_PAGE_1, /* left or upper arrow to scroll by page */
	1799	wxHT_SCROLLBAR_ARROW_PAGE_2, /* right or down */
	1800	wxHT_SCROLLBAR_THUMB, /* on the thumb */
	1801	wxHT_SCROLLBAR_BAR_1, /* bar to the left/above the thumb */
	1802	wxHT_SCROLLBAR_BAR_2, /* bar to the right/below the thumb */
	1803	wxHT_SCROLLBAR_LAST,
	1804
	1805	/* window */
	1806	wxHT_WINDOW_OUTSIDE, /* not in this window at all */
	1807	wxHT_WINDOW_INSIDE, /* in the client area */
	1808	wxHT_WINDOW_VERT_SCROLLBAR, /* on the vertical scrollbar */
	1809	wxHT_WINDOW_HORZ_SCROLLBAR, /* on the horizontal scrollbar */
	1810	wxHT_WINDOW_CORNER, /* on the corner between 2 scrollbars */
	1811
	1812	wxHT_MAX
	1813	};
	1814
	1815	/* ---------------------------------------------------------------------------- */
	1816	/* Possible SetSize flags */
	1817	/* ---------------------------------------------------------------------------- */
	1818
	1819	/* Use internally-calculated width if -1 */
	1820	#define wxSIZE_AUTO_WIDTH 0x0001
	1821	/* Use internally-calculated height if -1 */
	1822	#define wxSIZE_AUTO_HEIGHT 0x0002
	1823	/* Use internally-calculated width and height if each is -1 */
	1824	#define wxSIZE_AUTO (wxSIZE_AUTO_WIDTH\|wxSIZE_AUTO_HEIGHT)
	1825	/* Ignore missing (-1) dimensions (use existing). */
	1826	/* For readability only: test for wxSIZE_AUTO_WIDTH/HEIGHT in code. */
	1827	#define wxSIZE_USE_EXISTING 0x0000
	1828	/* Allow -1 as a valid position */
	1829	#define wxSIZE_ALLOW_MINUS_ONE 0x0004
	1830	/* Don't do parent client adjustments (for implementation only) */
	1831	#define wxSIZE_NO_ADJUSTMENTS 0x0008
	1832	/* Change the window position even if it seems to be already correct */
	1833	#define wxSIZE_FORCE 0x0010
	1834
	1835	/* ---------------------------------------------------------------------------- */
	1836	/* GDI descriptions */
	1837	/* ---------------------------------------------------------------------------- */
	1838
	1839	enum
	1840	{
	1841	/* Text font families */
	1842	wxDEFAULT = 70,
	1843	wxDECORATIVE,
	1844	wxROMAN,
	1845	wxSCRIPT,
	1846	wxSWISS,
	1847	wxMODERN,
	1848	wxTELETYPE, /* @@@@ */
	1849
	1850	/* Proportional or Fixed width fonts (not yet used) */
	1851	wxVARIABLE = 80,
	1852	wxFIXED,
	1853
	1854	wxNORMAL = 90,
	1855	wxLIGHT,
	1856	wxBOLD,
	1857	/* Also wxNORMAL for normal (non-italic text) */
	1858	wxITALIC,
	1859	wxSLANT,
	1860
	1861	/* Pen styles */
	1862	wxSOLID = 100,
	1863	wxDOT,
	1864	wxLONG_DASH,
	1865	wxSHORT_DASH,
	1866	wxDOT_DASH,
	1867	wxUSER_DASH,
	1868
	1869	wxTRANSPARENT,
	1870
	1871	/* Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */
	1872	/* Note also that stippling a Pen IS meaningfull, because a Line is */
	1873	wxSTIPPLE_MASK_OPAQUE, /* mask is used for blitting monochrome using text fore and back ground colors */
	1874	wxSTIPPLE_MASK, /* mask is used for masking areas in the stipple bitmap (TO DO) */
	1875	/* drawn with a Pen, and without any Brush -- and it can be stippled. */
	1876	wxSTIPPLE = 110,
	1877
	1878	wxBDIAGONAL_HATCH, /* In wxWidgets < 2.6 use WX_HATCH macro */
	1879	wxCROSSDIAG_HATCH, /* to verify these wx_HATCH are in style /
	1880	wxFDIAGONAL_HATCH, /* of wxBrush. In wxWidgets >= 2.6 use */
	1881	wxCROSS_HATCH, /* wxBrush::IsHatch() instead. */
	1882	wxHORIZONTAL_HATCH,
	1883	wxVERTICAL_HATCH,
	1884	wxFIRST_HATCH = wxBDIAGONAL_HATCH,
	1885	wxLAST_HATCH = wxVERTICAL_HATCH,
	1886
	1887	wxJOIN_BEVEL = 120,
	1888	wxJOIN_MITER,
	1889	wxJOIN_ROUND,
	1890
	1891	wxCAP_ROUND = 130,
	1892	wxCAP_PROJECTING,
	1893	wxCAP_BUTT
	1894	};
	1895
	1896	#if WXWIN_COMPATIBILITY_2_4
	1897	#define IS_HATCH(s) ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
	1898	#else
	1899	/* use wxBrush::IsHatch() instead thought wxMotif still uses it in src/motif/dcclient.cpp */
	1900	#endif
	1901
	1902	/* Logical ops */
	1903	typedef enum
	1904	{
	1905	wxCLEAR, wxROP_BLACK = wxCLEAR, wxBLIT_BLACKNESS = wxCLEAR, /* 0 */
	1906	wxXOR, wxROP_XORPEN = wxXOR, wxBLIT_SRCINVERT = wxXOR, /* src XOR dst */
	1907	wxINVERT, wxROP_NOT = wxINVERT, wxBLIT_DSTINVERT = wxINVERT, /* NOT dst */
	1908	wxOR_REVERSE, wxROP_MERGEPENNOT = wxOR_REVERSE, wxBLIT_00DD0228 = wxOR_REVERSE, /* src OR (NOT dst) */
	1909	wxAND_REVERSE, wxROP_MASKPENNOT = wxAND_REVERSE, wxBLIT_SRCERASE = wxAND_REVERSE, /* src AND (NOT dst) */
	1910	wxCOPY, wxROP_COPYPEN = wxCOPY, wxBLIT_SRCCOPY = wxCOPY, /* src */
	1911	wxAND, wxROP_MASKPEN = wxAND, wxBLIT_SRCAND = wxAND, /* src AND dst */
	1912	wxAND_INVERT, wxROP_MASKNOTPEN = wxAND_INVERT, wxBLIT_00220326 = wxAND_INVERT, /* (NOT src) AND dst */
	1913	wxNO_OP, wxROP_NOP = wxNO_OP, wxBLIT_00AA0029 = wxNO_OP, /* dst */
	1914	wxNOR, wxROP_NOTMERGEPEN = wxNOR, wxBLIT_NOTSRCERASE = wxNOR, /* (NOT src) AND (NOT dst) */
	1915	wxEQUIV, wxROP_NOTXORPEN = wxEQUIV, wxBLIT_00990066 = wxEQUIV, /* (NOT src) XOR dst */
	1916	wxSRC_INVERT, wxROP_NOTCOPYPEN = wxSRC_INVERT, wxBLIT_NOTSCRCOPY = wxSRC_INVERT, /* (NOT src) */
	1917	wxOR_INVERT, wxROP_MERGENOTPEN = wxOR_INVERT, wxBLIT_MERGEPAINT = wxOR_INVERT, /* (NOT src) OR dst */
	1918	wxNAND, wxROP_NOTMASKPEN = wxNAND, wxBLIT_007700E6 = wxNAND, /* (NOT src) OR (NOT dst) */
	1919	wxOR, wxROP_MERGEPEN = wxOR, wxBLIT_SRCPAINT = wxOR, /* src OR dst */
	1920	wxSET, wxROP_WHITE = wxSET, wxBLIT_WHITENESS = wxSET /* 1 */
	1921	} form_ops_t;
	1922
	1923	/* Flood styles */
	1924	enum
	1925	{
	1926	wxFLOOD_SURFACE = 1,
	1927	wxFLOOD_BORDER
	1928	};
	1929
	1930	/* Polygon filling mode */
	1931	enum
	1932	{
	1933	wxODDEVEN_RULE = 1,
	1934	wxWINDING_RULE
	1935	};
	1936
	1937	/* ToolPanel in wxFrame (VZ: unused?) */
	1938	enum
	1939	{
	1940	wxTOOL_TOP = 1,
	1941	wxTOOL_BOTTOM,
	1942	wxTOOL_LEFT,
	1943	wxTOOL_RIGHT
	1944	};
	1945
	1946	/* the values of the format constants should be the same as corresponding */
	1947	/* CF_XXX constants in Windows API */
	1948	enum wxDataFormatId
	1949	{
	1950	wxDF_INVALID = 0,
	1951	wxDF_TEXT = 1, /* CF_TEXT */
	1952	wxDF_BITMAP = 2, /* CF_BITMAP */
	1953	wxDF_METAFILE = 3, /* CF_METAFILEPICT */
	1954	wxDF_SYLK = 4,
	1955	wxDF_DIF = 5,
	1956	wxDF_TIFF = 6,
	1957	wxDF_OEMTEXT = 7, /* CF_OEMTEXT */
	1958	wxDF_DIB = 8, /* CF_DIB */
	1959	wxDF_PALETTE = 9,
	1960	wxDF_PENDATA = 10,
	1961	wxDF_RIFF = 11,
	1962	wxDF_WAVE = 12,
	1963	wxDF_UNICODETEXT = 13,
	1964	wxDF_ENHMETAFILE = 14,
	1965	wxDF_FILENAME = 15, /* CF_HDROP */
	1966	wxDF_LOCALE = 16,
	1967	wxDF_PRIVATE = 20,
	1968	wxDF_HTML = 30, /* Note: does not correspond to CF_ constant */
	1969	wxDF_MAX
	1970	};
	1971
	1972	/* Virtual keycodes */
	1973	enum wxKeyCode
	1974	{
	1975	WXK_BACK = 8,
	1976	WXK_TAB = 9,
	1977	WXK_RETURN = 13,
	1978	WXK_ESCAPE = 27,
	1979	WXK_SPACE = 32,
	1980	WXK_DELETE = 127,
	1981
	1982	/* These are, by design, not compatible with unicode characters.
	1983	If you want to get a unicode character from a key event, use
	1984	wxKeyEvent::GetUnicodeKey instead. */
	1985	WXK_START = 300,
	1986	WXK_LBUTTON,
	1987	WXK_RBUTTON,
	1988	WXK_CANCEL,
	1989	WXK_MBUTTON,
	1990	WXK_CLEAR,
	1991	WXK_SHIFT,
	1992	WXK_ALT,
	1993	WXK_CONTROL,
	1994	WXK_MENU,
	1995	WXK_PAUSE,
	1996	WXK_CAPITAL,
	1997	WXK_END,
	1998	WXK_HOME,
	1999	WXK_LEFT,
	2000	WXK_UP,
	2001	WXK_RIGHT,
	2002	WXK_DOWN,
	2003	WXK_SELECT,
	2004	WXK_PRINT,
	2005	WXK_EXECUTE,
	2006	WXK_SNAPSHOT,
	2007	WXK_INSERT,
	2008	WXK_HELP,
	2009	WXK_NUMPAD0,
	2010	WXK_NUMPAD1,
	2011	WXK_NUMPAD2,
	2012	WXK_NUMPAD3,
	2013	WXK_NUMPAD4,
	2014	WXK_NUMPAD5,
	2015	WXK_NUMPAD6,
	2016	WXK_NUMPAD7,
	2017	WXK_NUMPAD8,
	2018	WXK_NUMPAD9,
	2019	WXK_MULTIPLY,
	2020	WXK_ADD,
	2021	WXK_SEPARATOR,
	2022	WXK_SUBTRACT,
	2023	WXK_DECIMAL,
	2024	WXK_DIVIDE,
	2025	WXK_F1,
	2026	WXK_F2,
	2027	WXK_F3,
	2028	WXK_F4,
	2029	WXK_F5,
	2030	WXK_F6,
	2031	WXK_F7,
	2032	WXK_F8,
	2033	WXK_F9,
	2034	WXK_F10,
	2035	WXK_F11,
	2036	WXK_F12,
	2037	WXK_F13,
	2038	WXK_F14,
	2039	WXK_F15,
	2040	WXK_F16,
	2041	WXK_F17,
	2042	WXK_F18,
	2043	WXK_F19,
	2044	WXK_F20,
	2045	WXK_F21,
	2046	WXK_F22,
	2047	WXK_F23,
	2048	WXK_F24,
	2049	WXK_NUMLOCK,
	2050	WXK_SCROLL,
	2051	WXK_PAGEUP,
	2052	WXK_PAGEDOWN,
	2053	#if WXWIN_COMPATIBILITY_2_6
	2054	WXK_PRIOR = WXK_PAGEUP,
	2055	WXK_NEXT = WXK_PAGEDOWN,
	2056	#endif
	2057
	2058	WXK_NUMPAD_SPACE,
	2059	WXK_NUMPAD_TAB,
	2060	WXK_NUMPAD_ENTER,
	2061	WXK_NUMPAD_F1,
	2062	WXK_NUMPAD_F2,
	2063	WXK_NUMPAD_F3,
	2064	WXK_NUMPAD_F4,
	2065	WXK_NUMPAD_HOME,
	2066	WXK_NUMPAD_LEFT,
	2067	WXK_NUMPAD_UP,
	2068	WXK_NUMPAD_RIGHT,
	2069	WXK_NUMPAD_DOWN,
	2070	WXK_NUMPAD_PAGEUP,
	2071	WXK_NUMPAD_PAGEDOWN,
	2072	#if WXWIN_COMPATIBILITY_2_6
	2073	WXK_NUMPAD_PRIOR = WXK_NUMPAD_PAGEUP,
	2074	WXK_NUMPAD_NEXT = WXK_NUMPAD_PAGEDOWN,
	2075	#endif
	2076	WXK_NUMPAD_END,
	2077	WXK_NUMPAD_BEGIN,
	2078	WXK_NUMPAD_INSERT,
	2079	WXK_NUMPAD_DELETE,
	2080	WXK_NUMPAD_EQUAL,
	2081	WXK_NUMPAD_MULTIPLY,
	2082	WXK_NUMPAD_ADD,
	2083	WXK_NUMPAD_SEPARATOR,
	2084	WXK_NUMPAD_SUBTRACT,
	2085	WXK_NUMPAD_DECIMAL,
	2086	WXK_NUMPAD_DIVIDE,
	2087
	2088	WXK_WINDOWS_LEFT,
	2089	WXK_WINDOWS_RIGHT,
	2090	WXK_WINDOWS_MENU ,
	2091	WXK_COMMAND,
	2092
	2093	/* Hardware-specific buttons */
	2094	WXK_SPECIAL1 = 193,
	2095	WXK_SPECIAL2,
	2096	WXK_SPECIAL3,
	2097	WXK_SPECIAL4,
	2098	WXK_SPECIAL5,
	2099	WXK_SPECIAL6,
	2100	WXK_SPECIAL7,
	2101	WXK_SPECIAL8,
	2102	WXK_SPECIAL9,
	2103	WXK_SPECIAL10,
	2104	WXK_SPECIAL11,
	2105	WXK_SPECIAL12,
	2106	WXK_SPECIAL13,
	2107	WXK_SPECIAL14,
	2108	WXK_SPECIAL15,
	2109	WXK_SPECIAL16,
	2110	WXK_SPECIAL17,
	2111	WXK_SPECIAL18,
	2112	WXK_SPECIAL19,
	2113	WXK_SPECIAL20
	2114	};
	2115
	2116	/* This enum contains bit mask constants used in wxKeyEvent */
	2117	enum wxKeyModifier
	2118	{
	2119	wxMOD_NONE = 0x0000,
	2120	wxMOD_ALT = 0x0001,
	2121	wxMOD_CONTROL = 0x0002,
	2122	wxMOD_ALTGR = wxMOD_ALT \| wxMOD_CONTROL,
	2123	wxMOD_SHIFT = 0x0004,
	2124	wxMOD_META = 0x0008,
	2125	wxMOD_WIN = wxMOD_META,
	2126	#if defined(__WXMAC__) \|\| defined(__WXCOCOA__)
	2127	wxMOD_CMD = wxMOD_META,
	2128	#else
	2129	wxMOD_CMD = wxMOD_CONTROL,
	2130	#endif
	2131	wxMOD_ALL = 0xffff
	2132	};
	2133
	2134	/* Mapping modes (same values as used by Windows, don't change) */
	2135	enum
	2136	{
	2137	wxMM_TEXT = 1,
	2138	wxMM_LOMETRIC,
	2139	wxMM_HIMETRIC,
	2140	wxMM_LOENGLISH,
	2141	wxMM_HIENGLISH,
	2142	wxMM_TWIPS,
	2143	wxMM_ISOTROPIC,
	2144	wxMM_ANISOTROPIC,
	2145	wxMM_POINTS,
	2146	wxMM_METRIC
	2147	};
	2148
	2149	/* Shortcut for easier dialog-unit-to-pixel conversion */
	2150	#define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
	2151
	2152	/* Paper types */
	2153	typedef enum
	2154	{
	2155	wxPAPER_NONE, /* Use specific dimensions */
	2156	wxPAPER_LETTER, /* Letter, 8 1/2 by 11 inches */
	2157	wxPAPER_LEGAL, /* Legal, 8 1/2 by 14 inches */
	2158	wxPAPER_A4, /* A4 Sheet, 210 by 297 millimeters */
	2159	wxPAPER_CSHEET, /* C Sheet, 17 by 22 inches */
	2160	wxPAPER_DSHEET, /* D Sheet, 22 by 34 inches */
	2161	wxPAPER_ESHEET, /* E Sheet, 34 by 44 inches */
	2162	wxPAPER_LETTERSMALL, /* Letter Small, 8 1/2 by 11 inches */
	2163	wxPAPER_TABLOID, /* Tabloid, 11 by 17 inches */
	2164	wxPAPER_LEDGER, /* Ledger, 17 by 11 inches */
	2165	wxPAPER_STATEMENT, /* Statement, 5 1/2 by 8 1/2 inches */
	2166	wxPAPER_EXECUTIVE, /* Executive, 7 1/4 by 10 1/2 inches */
	2167	wxPAPER_A3, /* A3 sheet, 297 by 420 millimeters */
	2168	wxPAPER_A4SMALL, /* A4 small sheet, 210 by 297 millimeters */
	2169	wxPAPER_A5, /* A5 sheet, 148 by 210 millimeters */
	2170	wxPAPER_B4, /* B4 sheet, 250 by 354 millimeters */
	2171	wxPAPER_B5, /* B5 sheet, 182-by-257-millimeter paper */
	2172	wxPAPER_FOLIO, /* Folio, 8-1/2-by-13-inch paper */
	2173	wxPAPER_QUARTO, /* Quarto, 215-by-275-millimeter paper */
	2174	wxPAPER_10X14, /* 10-by-14-inch sheet */
	2175	wxPAPER_11X17, /* 11-by-17-inch sheet */
	2176	wxPAPER_NOTE, /* Note, 8 1/2 by 11 inches */
	2177	wxPAPER_ENV_9, /* #9 Envelope, 3 7/8 by 8 7/8 inches */
	2178	wxPAPER_ENV_10, /* #10 Envelope, 4 1/8 by 9 1/2 inches */
	2179	wxPAPER_ENV_11, /* #11 Envelope, 4 1/2 by 10 3/8 inches */
	2180	wxPAPER_ENV_12, /* #12 Envelope, 4 3/4 by 11 inches */
	2181	wxPAPER_ENV_14, /* #14 Envelope, 5 by 11 1/2 inches */
	2182	wxPAPER_ENV_DL, /* DL Envelope, 110 by 220 millimeters */
	2183	wxPAPER_ENV_C5, /* C5 Envelope, 162 by 229 millimeters */
	2184	wxPAPER_ENV_C3, /* C3 Envelope, 324 by 458 millimeters */
	2185	wxPAPER_ENV_C4, /* C4 Envelope, 229 by 324 millimeters */
	2186	wxPAPER_ENV_C6, /* C6 Envelope, 114 by 162 millimeters */
	2187	wxPAPER_ENV_C65, /* C65 Envelope, 114 by 229 millimeters */
	2188	wxPAPER_ENV_B4, /* B4 Envelope, 250 by 353 millimeters */
	2189	wxPAPER_ENV_B5, /* B5 Envelope, 176 by 250 millimeters */
	2190	wxPAPER_ENV_B6, /* B6 Envelope, 176 by 125 millimeters */
	2191	wxPAPER_ENV_ITALY, /* Italy Envelope, 110 by 230 millimeters */
	2192	wxPAPER_ENV_MONARCH, /* Monarch Envelope, 3 7/8 by 7 1/2 inches */
	2193	wxPAPER_ENV_PERSONAL, /* 6 3/4 Envelope, 3 5/8 by 6 1/2 inches */
	2194	wxPAPER_FANFOLD_US, /* US Std Fanfold, 14 7/8 by 11 inches */
	2195	wxPAPER_FANFOLD_STD_GERMAN, /* German Std Fanfold, 8 1/2 by 12 inches */
	2196	wxPAPER_FANFOLD_LGL_GERMAN, /* German Legal Fanfold, 8 1/2 by 13 inches */
	2197
	2198	wxPAPER_ISO_B4, /* B4 (ISO) 250 x 353 mm */
	2199	wxPAPER_JAPANESE_POSTCARD, /* Japanese Postcard 100 x 148 mm */
	2200	wxPAPER_9X11, /* 9 x 11 in */
	2201	wxPAPER_10X11, /* 10 x 11 in */
	2202	wxPAPER_15X11, /* 15 x 11 in */
	2203	wxPAPER_ENV_INVITE, /* Envelope Invite 220 x 220 mm */
	2204	wxPAPER_LETTER_EXTRA, /* Letter Extra 9 \275 x 12 in */
	2205	wxPAPER_LEGAL_EXTRA, /* Legal Extra 9 \275 x 15 in */
	2206	wxPAPER_TABLOID_EXTRA, /* Tabloid Extra 11.69 x 18 in */
	2207	wxPAPER_A4_EXTRA, /* A4 Extra 9.27 x 12.69 in */
	2208	wxPAPER_LETTER_TRANSVERSE, /* Letter Transverse 8 \275 x 11 in */
	2209	wxPAPER_A4_TRANSVERSE, /* A4 Transverse 210 x 297 mm */
	2210	wxPAPER_LETTER_EXTRA_TRANSVERSE, /* Letter Extra Transverse 9\275 x 12 in */
	2211	wxPAPER_A_PLUS, /* SuperA/SuperA/A4 227 x 356 mm */
	2212	wxPAPER_B_PLUS, /* SuperB/SuperB/A3 305 x 487 mm */
	2213	wxPAPER_LETTER_PLUS, /* Letter Plus 8.5 x 12.69 in */
	2214	wxPAPER_A4_PLUS, /* A4 Plus 210 x 330 mm */
	2215	wxPAPER_A5_TRANSVERSE, /* A5 Transverse 148 x 210 mm */
	2216	wxPAPER_B5_TRANSVERSE, /* B5 (JIS) Transverse 182 x 257 mm */
	2217	wxPAPER_A3_EXTRA, /* A3 Extra 322 x 445 mm */
	2218	wxPAPER_A5_EXTRA, /* A5 Extra 174 x 235 mm */
	2219	wxPAPER_B5_EXTRA, /* B5 (ISO) Extra 201 x 276 mm */
	2220	wxPAPER_A2, /* A2 420 x 594 mm */
	2221	wxPAPER_A3_TRANSVERSE, /* A3 Transverse 297 x 420 mm */
	2222	wxPAPER_A3_EXTRA_TRANSVERSE, /* A3 Extra Transverse 322 x 445 mm */
	2223
	2224	wxPAPER_DBL_JAPANESE_POSTCARD,/* Japanese Double Postcard 200 x 148 mm */
	2225	wxPAPER_A6, /* A6 105 x 148 mm */
	2226	wxPAPER_JENV_KAKU2, /* Japanese Envelope Kaku #2 */
	2227	wxPAPER_JENV_KAKU3, /* Japanese Envelope Kaku #3 */
	2228	wxPAPER_JENV_CHOU3, /* Japanese Envelope Chou #3 */
	2229	wxPAPER_JENV_CHOU4, /* Japanese Envelope Chou #4 */
	2230	wxPAPER_LETTER_ROTATED, /* Letter Rotated 11 x 8 1/2 in */
	2231	wxPAPER_A3_ROTATED, /* A3 Rotated 420 x 297 mm */
	2232	wxPAPER_A4_ROTATED, /* A4 Rotated 297 x 210 mm */
	2233	wxPAPER_A5_ROTATED, /* A5 Rotated 210 x 148 mm */
	2234	wxPAPER_B4_JIS_ROTATED, /* B4 (JIS) Rotated 364 x 257 mm */
	2235	wxPAPER_B5_JIS_ROTATED, /* B5 (JIS) Rotated 257 x 182 mm */
	2236	wxPAPER_JAPANESE_POSTCARD_ROTATED,/* Japanese Postcard Rotated 148 x 100 mm */
	2237	wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED,/* Double Japanese Postcard Rotated 148 x 200 mm */
	2238	wxPAPER_A6_ROTATED, /* A6 Rotated 148 x 105 mm */
	2239	wxPAPER_JENV_KAKU2_ROTATED, /* Japanese Envelope Kaku #2 Rotated */
	2240	wxPAPER_JENV_KAKU3_ROTATED, /* Japanese Envelope Kaku #3 Rotated */
	2241	wxPAPER_JENV_CHOU3_ROTATED, /* Japanese Envelope Chou #3 Rotated */
	2242	wxPAPER_JENV_CHOU4_ROTATED, /* Japanese Envelope Chou #4 Rotated */
	2243	wxPAPER_B6_JIS, /* B6 (JIS) 128 x 182 mm */
	2244	wxPAPER_B6_JIS_ROTATED, /* B6 (JIS) Rotated 182 x 128 mm */
	2245	wxPAPER_12X11, /* 12 x 11 in */
	2246	wxPAPER_JENV_YOU4, /* Japanese Envelope You #4 */
	2247	wxPAPER_JENV_YOU4_ROTATED, /* Japanese Envelope You #4 Rotated */
	2248	wxPAPER_P16K, /* PRC 16K 146 x 215 mm */
	2249	wxPAPER_P32K, /* PRC 32K 97 x 151 mm */
	2250	wxPAPER_P32KBIG, /* PRC 32K(Big) 97 x 151 mm */
	2251	wxPAPER_PENV_1, /* PRC Envelope #1 102 x 165 mm */
	2252	wxPAPER_PENV_2, /* PRC Envelope #2 102 x 176 mm */
	2253	wxPAPER_PENV_3, /* PRC Envelope #3 125 x 176 mm */
	2254	wxPAPER_PENV_4, /* PRC Envelope #4 110 x 208 mm */
	2255	wxPAPER_PENV_5, /* PRC Envelope #5 110 x 220 mm */
	2256	wxPAPER_PENV_6, /* PRC Envelope #6 120 x 230 mm */
	2257	wxPAPER_PENV_7, /* PRC Envelope #7 160 x 230 mm */
	2258	wxPAPER_PENV_8, /* PRC Envelope #8 120 x 309 mm */
	2259	wxPAPER_PENV_9, /* PRC Envelope #9 229 x 324 mm */
	2260	wxPAPER_PENV_10, /* PRC Envelope #10 324 x 458 mm */
	2261	wxPAPER_P16K_ROTATED, /* PRC 16K Rotated */
	2262	wxPAPER_P32K_ROTATED, /* PRC 32K Rotated */
	2263	wxPAPER_P32KBIG_ROTATED, /* PRC 32K(Big) Rotated */
	2264	wxPAPER_PENV_1_ROTATED, /* PRC Envelope #1 Rotated 165 x 102 mm */
	2265	wxPAPER_PENV_2_ROTATED, /* PRC Envelope #2 Rotated 176 x 102 mm */
	2266	wxPAPER_PENV_3_ROTATED, /* PRC Envelope #3 Rotated 176 x 125 mm */
	2267	wxPAPER_PENV_4_ROTATED, /* PRC Envelope #4 Rotated 208 x 110 mm */
	2268	wxPAPER_PENV_5_ROTATED, /* PRC Envelope #5 Rotated 220 x 110 mm */
	2269	wxPAPER_PENV_6_ROTATED, /* PRC Envelope #6 Rotated 230 x 120 mm */
	2270	wxPAPER_PENV_7_ROTATED, /* PRC Envelope #7 Rotated 230 x 160 mm */
	2271	wxPAPER_PENV_8_ROTATED, /* PRC Envelope #8 Rotated 309 x 120 mm */
	2272	wxPAPER_PENV_9_ROTATED, /* PRC Envelope #9 Rotated 324 x 229 mm */
	2273	wxPAPER_PENV_10_ROTATED /* PRC Envelope #10 Rotated 458 x 324 m */
	2274	} wxPaperSize;
	2275
	2276	/* Printing orientation */
	2277	#ifndef wxPORTRAIT
	2278	#define wxPORTRAIT 1
	2279	#define wxLANDSCAPE 2
	2280	#endif
	2281
	2282	/* Duplex printing modes
	2283	*/
	2284
	2285	enum wxDuplexMode
	2286	{
	2287	wxDUPLEX_SIMPLEX, /* Non-duplex */
	2288	wxDUPLEX_HORIZONTAL,
	2289	wxDUPLEX_VERTICAL
	2290	};
	2291
	2292	/* Print quality.
	2293	*/
	2294
	2295	#define wxPRINT_QUALITY_HIGH -1
	2296	#define wxPRINT_QUALITY_MEDIUM -2
	2297	#define wxPRINT_QUALITY_LOW -3
	2298	#define wxPRINT_QUALITY_DRAFT -4
	2299
	2300	typedef int wxPrintQuality;
	2301
	2302	/* Print mode (currently PostScript only)
	2303	*/
	2304
	2305	enum wxPrintMode
	2306	{
	2307	wxPRINT_MODE_NONE = 0,
	2308	wxPRINT_MODE_PREVIEW = 1, /* Preview in external application */
	2309	wxPRINT_MODE_FILE = 2, /* Print to file */
	2310	wxPRINT_MODE_PRINTER = 3, /* Send to printer */
	2311	wxPRINT_MODE_STREAM = 4 /* Send postscript data into a stream */
	2312	};
	2313
	2314	/* ---------------------------------------------------------------------------- */
	2315	/* UpdateWindowUI flags */
	2316	/* ---------------------------------------------------------------------------- */
	2317
	2318	enum wxUpdateUI
	2319	{
	2320	wxUPDATE_UI_NONE = 0x0000,
	2321	wxUPDATE_UI_RECURSE = 0x0001,
	2322	wxUPDATE_UI_FROMIDLE = 0x0002 /* Invoked from On(Internal)Idle */
	2323	};
	2324
	2325	/* ---------------------------------------------------------------------------- */
	2326	/* miscellaneous */
	2327	/* ---------------------------------------------------------------------------- */
	2328
	2329	/* define this macro if font handling is done using the X font names */
	2330	#if (defined(__WXGTK__) && !defined(__WXGTK20__)) \|\| defined(__X__)
	2331	#define _WX_X_FONTLIKE
	2332	#endif
	2333
	2334	/* macro to specify "All Files" on different platforms */
	2335	#if defined(__WXMSW__) \|\| defined(__WXPM__)
	2336	# define wxALL_FILES_PATTERN wxT(".")
	2337	# define wxALL_FILES gettext_noop("All files (.)\|.")
	2338	#else
	2339	# define wxALL_FILES_PATTERN wxT("*")
	2340	# define wxALL_FILES gettext_noop("All files ()\|")
	2341	#endif
	2342
	2343	#if defined(__CYGWIN__) && defined(__WXMSW__)
	2344	# if wxUSE_STL \|\| defined(wxUSE_STD_STRING)
	2345	/*
	2346	NASTY HACK because the gethostname in sys/unistd.h which the gnu
	2347	stl includes and wx builds with by default clash with each other
	2348	(windows version 2nd param is int, sys/unistd.h version is unsigned
	2349	int).
	2350	*/
	2351	# define gethostname gethostnameHACK
	2352	# include <unistd.h>
	2353	# undef gethostname
	2354	# endif
	2355	#endif
	2356
	2357	/* --------------------------------------------------------------------------- */
	2358	/* macros that enable wxWidgets apps to be compiled in absence of the */
	2359	/* sytem headers, although some platform specific types are used in the */
	2360	/* platform specific (implementation) parts of the headers */
	2361	/* --------------------------------------------------------------------------- */
	2362
	2363	#ifdef __WXMAC__
	2364
	2365	#define WX_OPAQUE_TYPE( name ) struct wxOpaque##name
	2366
	2367	typedef unsigned char WXCOLORREF[6];
	2368	typedef void* WXCGIMAGEREF;
	2369	typedef void* WXHBITMAP;
	2370	typedef void* WXHCURSOR;
	2371	typedef void* WXHRGN;
	2372	typedef void* WXRECTPTR;
	2373	typedef void* WXPOINTPTR;
	2374	typedef void* WXHWND;
	2375	typedef void* WXEVENTREF;
	2376	typedef void* WXEVENTHANDLERREF;
	2377	typedef void* WXEVENTHANDLERCALLREF;
	2378	typedef void* WXAPPLEEVENTREF;
	2379	typedef void* WXHDC;
	2380	typedef void* WXHMENU;
	2381	typedef unsigned int WXUINT;
	2382	typedef unsigned long WXDWORD;
	2383	typedef unsigned short WXWORD;
	2384
	2385	typedef WX_OPAQUE_TYPE(CIconHandle ) * WXHICON ;
	2386	typedef WX_OPAQUE_TYPE(PicHandle ) * WXHMETAFILE ;
	2387
	2388
	2389	/* typedef void* WXWidget; */
	2390	/* typedef void* WXWindow; */
	2391	typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ;
	2392	typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ;
	2393	typedef void* WXDisplay;
	2394
	2395	/* typedef WindowPtr WXHWND; */
	2396	/* typedef Handle WXHANDLE; */
	2397	/* typedef CIconHandle WXHICON; */
	2398	/* typedef unsigned long WXHFONT; */
	2399	/* typedef MenuHandle WXHMENU; */
	2400	/* typedef unsigned long WXHPEN; */
	2401	/* typedef unsigned long WXHBRUSH; */
	2402	/* typedef unsigned long WXHPALETTE; */
	2403	/* typedef CursHandle WXHCURSOR; */
	2404	/* typedef RgnHandle WXHRGN; */
	2405	/* typedef unsigned long WXHACCEL; */
	2406	/* typedef unsigned long WXHINSTANCE; */
	2407	/* typedef unsigned long WXHIMAGELIST; */
	2408	/* typedef unsigned long WXHGLOBAL; */
	2409	/* typedef GrafPtr WXHDC; */
	2410	/* typedef unsigned int WXWPARAM; */
	2411	/* typedef long WXLPARAM; */
	2412	/* typedef void * WXRGNDATA; */
	2413	/* typedef void * WXMSG; */
	2414	/* typedef unsigned long WXHCONV; */
	2415	/* typedef unsigned long WXHKEY; */
	2416	/* typedef void * WXDRAWITEMSTRUCT; */
	2417	/* typedef void * WXMEASUREITEMSTRUCT; */
	2418	/* typedef void * WXLPCREATESTRUCT; */
	2419	/* typedef int (WXFARPROC)(); /
	2420
	2421	/* typedef WindowPtr WXWindow; */
	2422	/* typedef ControlHandle WXWidget; */
	2423
	2424	#endif
	2425
	2426	#ifdef __WXCOCOA__
	2427
	2428	/* NOTE: This ought to work with other compilers too, but I'm being cautious */
	2429	#if (defined(__GNUC__) && defined(__APPLE__)) \|\| defined(__MWERKS__)
	2430	/* It's desirable to have type safety for Objective-C(++) code as it does
	2431	at least catch typos of method names among other things. However, it
	2432	is not possible to declare an Objective-C class from plain old C or C++
	2433	code. Furthermore, because of C++ name mangling, the type name must
	2434	be the same for both C++ and Objective-C++ code. Therefore, we define
	2435	what should be a pointer to an Objective-C class as a pointer to a plain
	2436	old C struct with the same name. Unfortunately, because the compiler
	2437	does not see a struct as an Objective-C class we cannot declare it
	2438	as a struct in Objective-C(++) mode.
	2439	*/
	2440	#if defined(__OBJC__)
	2441	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2442	@class klass; \
	2443	typedef klass *WX_##klass
	2444	#else /* not defined(__OBJC__) */
	2445	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2446	typedef struct klass *WX_##klass
	2447	#endif /* defined(__OBJC__) */
	2448
	2449	#else /* not Apple's GNU or CodeWarrior */
	2450	#warning "Objective-C types will not be checked by the compiler."
	2451	/* NOTE: typedef struct objc_object id; /
	2452	/* IOW, we're declaring these using the id type without using that name, */
	2453	/* since "id" is used extensively not only within wxWidgets itself, but */
	2454	/* also in wxWidgets application code. The following works fine when */
	2455	/* compiling C(++) code, and works without typesafety for Obj-C(++) code */
	2456	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2457	typedef struct objc_object *WX_##klass
	2458
	2459	#endif /* (defined(__GNUC__) && defined(__APPLE__)) \|\| defined(__MWERKS__) */
	2460
	2461	DECLARE_WXCOCOA_OBJC_CLASS(NSApplication);
	2462	DECLARE_WXCOCOA_OBJC_CLASS(NSBitmapImageRep);
	2463	DECLARE_WXCOCOA_OBJC_CLASS(NSBox);
	2464	DECLARE_WXCOCOA_OBJC_CLASS(NSButton);
	2465	DECLARE_WXCOCOA_OBJC_CLASS(NSColor);
	2466	DECLARE_WXCOCOA_OBJC_CLASS(NSColorPanel);
	2467	DECLARE_WXCOCOA_OBJC_CLASS(NSControl);
	2468	DECLARE_WXCOCOA_OBJC_CLASS(NSCursor);
	2469	DECLARE_WXCOCOA_OBJC_CLASS(NSEvent);
	2470	DECLARE_WXCOCOA_OBJC_CLASS(NSFontPanel);
	2471	DECLARE_WXCOCOA_OBJC_CLASS(NSImage);
	2472	DECLARE_WXCOCOA_OBJC_CLASS(NSLayoutManager);
	2473	DECLARE_WXCOCOA_OBJC_CLASS(NSMenu);
	2474	DECLARE_WXCOCOA_OBJC_CLASS(NSMenuExtra);
	2475	DECLARE_WXCOCOA_OBJC_CLASS(NSMenuItem);
	2476	DECLARE_WXCOCOA_OBJC_CLASS(NSMutableArray);
	2477	DECLARE_WXCOCOA_OBJC_CLASS(NSNotification);
	2478	DECLARE_WXCOCOA_OBJC_CLASS(NSObject);
	2479	DECLARE_WXCOCOA_OBJC_CLASS(NSPanel);
	2480	DECLARE_WXCOCOA_OBJC_CLASS(NSScrollView);
	2481	DECLARE_WXCOCOA_OBJC_CLASS(NSSound);
	2482	DECLARE_WXCOCOA_OBJC_CLASS(NSStatusItem);
	2483	DECLARE_WXCOCOA_OBJC_CLASS(NSTableColumn);
	2484	DECLARE_WXCOCOA_OBJC_CLASS(NSTableView);
	2485	DECLARE_WXCOCOA_OBJC_CLASS(NSTextContainer);
	2486	DECLARE_WXCOCOA_OBJC_CLASS(NSTextField);
	2487	DECLARE_WXCOCOA_OBJC_CLASS(NSTextStorage);
	2488	DECLARE_WXCOCOA_OBJC_CLASS(NSThread);
	2489	DECLARE_WXCOCOA_OBJC_CLASS(NSWindow);
	2490	DECLARE_WXCOCOA_OBJC_CLASS(NSView);
	2491	typedef WX_NSView WXWidget; /* wxWidgets BASE definition */
	2492	#endif /* __WXCOCOA__ */
	2493
	2494	#if defined(__WXPALMOS__)
	2495
	2496	typedef void * WXHWND;
	2497	typedef void * WXHANDLE;
	2498	typedef void * WXHICON;
	2499	typedef void * WXHFONT;
	2500	typedef void * WXHMENU;
	2501	typedef void * WXHPEN;
	2502	typedef void * WXHBRUSH;
	2503	typedef void * WXHPALETTE;
	2504	typedef void * WXHCURSOR;
	2505	typedef void * WXHRGN;
	2506	typedef void * WXHACCEL;
	2507	typedef void * WXHINSTANCE;
	2508	typedef void * WXHBITMAP;
	2509	typedef void * WXHIMAGELIST;
	2510	typedef void * WXHGLOBAL;
	2511	typedef void * WXHDC;
	2512	typedef unsigned int WXUINT;
	2513	typedef unsigned long WXDWORD;
	2514	typedef unsigned short WXWORD;
	2515
	2516	typedef unsigned long WXCOLORREF;
	2517	typedef struct tagMSG WXMSG;
	2518
	2519	typedef WXHWND WXWINHANDLE; /* WinHandle of PalmOS */
	2520	typedef WXWINHANDLE WXWidget;
	2521
	2522	typedef void * WXFORMPTR;
	2523	typedef void * WXEVENTPTR;
	2524	typedef void * WXRECTANGLEPTR;
	2525
	2526	#endif /* __WXPALMOS__ */
	2527
	2528
	2529	/* ABX: check __WIN32__ instead of __WXMSW__ for the same MSWBase in any Win32 port */
	2530	#if defined(__WIN32__)
	2531
	2532	/* the keywords needed for WinMain() declaration */
	2533	#ifndef WXFAR
	2534	# define WXFAR
	2535	#endif
	2536
	2537	/* Stand-ins for Windows types to avoid #including all of windows.h */
	2538	typedef void * WXHWND;
	2539	typedef void * WXHANDLE;
	2540	typedef void * WXHICON;
	2541	typedef void * WXHFONT;
	2542	typedef void * WXHMENU;
	2543	typedef void * WXHPEN;
	2544	typedef void * WXHBRUSH;
	2545	typedef void * WXHPALETTE;
	2546	typedef void * WXHCURSOR;
	2547	typedef void * WXHRGN;
	2548	typedef void * WXRECTPTR;
	2549	typedef void * WXHACCEL;
	2550	typedef void WXFAR * WXHINSTANCE;
	2551	typedef void * WXHBITMAP;
	2552	typedef void * WXHIMAGELIST;
	2553	typedef void * WXHGLOBAL;
	2554	typedef void * WXHDC;
	2555	typedef unsigned int WXUINT;
	2556	typedef unsigned long WXDWORD;
	2557	typedef unsigned short WXWORD;
	2558
	2559	typedef unsigned long WXCOLORREF;
	2560	typedef void * WXRGNDATA;
	2561	typedef struct tagMSG WXMSG;
	2562	typedef void * WXHCONV;
	2563	typedef void * WXHKEY;
	2564	typedef void * WXHTREEITEM;
	2565
	2566	typedef void * WXDRAWITEMSTRUCT;
	2567	typedef void * WXMEASUREITEMSTRUCT;
	2568	typedef void * WXLPCREATESTRUCT;
	2569
	2570	typedef WXHWND WXWidget;
	2571
	2572	#ifdef __WIN64__
	2573	typedef unsigned __int64 WXWPARAM;
	2574	typedef __int64 WXLPARAM;
	2575	typedef __int64 WXLRESULT;
	2576	#else
	2577	typedef unsigned int WXWPARAM;
	2578	typedef long WXLPARAM;
	2579	typedef long WXLRESULT;
	2580	#endif
	2581
	2582	#if defined(__GNUWIN32__) \|\| defined(__WXMICROWIN__)
	2583	typedef int (*WXFARPROC)();
	2584	#else
	2585	typedef int (__stdcall *WXFARPROC)();
	2586	#endif
	2587	#endif /* __WIN32__ */
	2588
	2589
	2590	#if defined(__OS2__)
	2591	typedef unsigned long DWORD;
	2592	typedef unsigned short WORD;
	2593	#endif
	2594
	2595	#if defined(__WXPM__) \|\| defined(__EMX__)
	2596	#ifdef __WXPM__
	2597	/* Stand-ins for OS/2 types, to avoid #including all of os2.h */
	2598	typedef unsigned long WXHWND;
	2599	typedef unsigned long WXHANDLE;
	2600	typedef unsigned long WXHICON;
	2601	typedef unsigned long WXHFONT;
	2602	typedef unsigned long WXHMENU;
	2603	typedef unsigned long WXHPEN;
	2604	typedef unsigned long WXHBRUSH;
	2605	typedef unsigned long WXHPALETTE;
	2606	typedef unsigned long WXHCURSOR;
	2607	typedef unsigned long WXHRGN;
	2608	typedef unsigned long WXHACCEL;
	2609	typedef unsigned long WXHBITMAP;
	2610	typedef unsigned long WXHDC;
	2611	typedef unsigned int WXUINT;
	2612	typedef unsigned long WXDWORD;
	2613	typedef unsigned short WXWORD;
	2614
	2615	typedef unsigned long WXCOLORREF;
	2616	typedef void * WXMSG;
	2617	typedef unsigned long WXHTREEITEM;
	2618
	2619	typedef void * WXDRAWITEMSTRUCT;
	2620	typedef void * WXMEASUREITEMSTRUCT;
	2621	typedef void * WXLPCREATESTRUCT;
	2622
	2623	typedef WXHWND WXWidget;
	2624	#endif
	2625	#ifdef __EMX__
	2626	/* Need a well-known type for WXFARPROC
	2627	below. MPARAM is typedef'ed too late. */
	2628	#define WXWPARAM void *
	2629	#define WXLPARAM void *
	2630	#else
	2631	#define WXWPARAM MPARAM
	2632	#define WXLPARAM MPARAM
	2633	#endif
	2634	#define RECT RECTL
	2635	#define LOGFONT FATTRS
	2636	#define LOWORD SHORT1FROMMP
	2637	#define HIWORD SHORT2FROMMP
	2638
	2639	typedef unsigned long WXMPARAM;
	2640	typedef unsigned long WXMSGID;
	2641	typedef void* WXRESULT;
	2642	/* typedef int (WXFARPROC)(); /
	2643	/* some windows handles not defined by PM */
	2644	typedef unsigned long HANDLE;
	2645	typedef unsigned long HICON;
	2646	typedef unsigned long HFONT;
	2647	typedef unsigned long HMENU;
	2648	typedef unsigned long HPEN;
	2649	typedef unsigned long HBRUSH;
	2650	typedef unsigned long HPALETTE;
	2651	typedef unsigned long HCURSOR;
	2652	typedef unsigned long HINSTANCE;
	2653	typedef unsigned long HIMAGELIST;
	2654	typedef unsigned long HGLOBAL;
	2655	#endif /* WXPM \|\| EMX */
	2656
	2657	#if defined (__WXPM__)
	2658	/* WIN32 graphics types for OS/2 GPI */
	2659
	2660	/* RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def */
	2661	#define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) \| ((unsigned char)(g) << 8)) \| ((unsigned char)(r) << 16))
	2662
	2663	typedef unsigned long COLORREF;
	2664	#define GetRValue(rgb) ((unsigned char)((rgb) >> 16))
	2665	#define GetGValue(rgb) ((unsigned char)(((unsigned short)(rgb)) >> 8))
	2666	#define GetBValue(rgb) ((unsigned char)(rgb))
	2667	#define PALETTEINDEX(i) ((COLORREF)(0x01000000 \| (DWORD)(WORD)(i)))
	2668	#define PALETTERGB(r,g,b) (0x02000000 \| OS2RGB(r,g,b))
	2669	/* OS2's RGB/RGB2 is backwards from this */
	2670	typedef struct tagPALETTEENTRY
	2671	{
	2672	char bRed;
	2673	char bGreen;
	2674	char bBlue;
	2675	char bFlags;
	2676	} PALETTEENTRY;
	2677	typedef struct tagLOGPALETTE
	2678	{
	2679	WORD palVersion;
	2680	WORD palNumentries;
	2681	WORD PALETTEENTRY[1];
	2682	} LOGPALETTE;
	2683
	2684	#if (defined(__VISAGECPP__) && (__IBMCPP__ < 400)) \|\| defined (__WATCOMC__)
	2685	/* VA 3.0 for some reason needs base data types when typedefing a proc proto??? */
	2686	typedef void* (_System WXFARPROC)(unsigned long, unsigned long, void, void*);
	2687	#else
	2688	#if defined(__EMX__) && !defined(_System)
	2689	#define _System
	2690	#endif
	2691	typedef WXRESULT (_System *WXFARPROC)(WXHWND, WXMSGID, WXWPARAM, WXLPARAM);
	2692	#endif
	2693
	2694	#endif /* __WXPM__ */
	2695
	2696
	2697	#if defined(__WXMOTIF__) \|\| defined(__WXX11__)
	2698	/* Stand-ins for X/Xt/Motif types */
	2699	typedef void* WXWindow;
	2700	typedef void* WXWidget;
	2701	typedef void* WXAppContext;
	2702	typedef void* WXColormap;
	2703	typedef void* WXColor;
	2704	typedef void WXDisplay;
	2705	typedef void WXEvent;
	2706	typedef void* WXCursor;
	2707	typedef void* WXPixmap;
	2708	typedef void* WXFontStructPtr;
	2709	typedef void* WXGC;
	2710	typedef void* WXRegion;
	2711	typedef void* WXFont;
	2712	typedef void* WXImage;
	2713	typedef void* WXFontList;
	2714	typedef void* WXFontSet;
	2715	typedef void* WXRendition;
	2716	typedef void* WXRenderTable;
	2717	typedef void* WXFontType; /* either a XmFontList or XmRenderTable */
	2718	typedef void* WXString;
	2719
	2720	typedef unsigned long Atom; /* this might fail on a few architectures */
	2721	typedef long WXPixel; /* safety catch in src/motif/colour.cpp */
	2722
	2723	#endif /* Motif */
	2724
	2725	#ifdef __WXGTK__
	2726
	2727	/* Stand-ins for GLIB types */
	2728	typedef char gchar;
	2729	typedef signed char gint8;
	2730	typedef int gint;
	2731	typedef unsigned guint;
	2732	typedef unsigned long gulong;
	2733	typedef void* gpointer;
	2734	typedef struct _GSList GSList;
	2735
	2736	/* Stand-ins for GDK types */
	2737	typedef struct _GdkColor GdkColor;
	2738	typedef struct _GdkColormap GdkColormap;
	2739	typedef struct _GdkFont GdkFont;
	2740	typedef struct _GdkGC GdkGC;
	2741	typedef struct _GdkVisual GdkVisual;
	2742
	2743	#ifdef __WXGTK20__
	2744	typedef struct _GdkAtom *GdkAtom;
	2745	typedef struct _GdkDrawable GdkWindow;
	2746	typedef struct _GdkDrawable GdkBitmap;
	2747	typedef struct _GdkDrawable GdkPixmap;
	2748	#else /* GTK+ 1.2 */
	2749	typedef gulong GdkAtom;
	2750	typedef struct _GdkWindow GdkWindow;
	2751	typedef struct _GdkWindow GdkBitmap;
	2752	typedef struct _GdkWindow GdkPixmap;
	2753	#endif /* GTK+ 1.2/2.0 */
	2754
	2755	typedef struct _GdkCursor GdkCursor;
	2756	typedef struct _GdkRegion GdkRegion;
	2757	typedef struct _GdkDragContext GdkDragContext;
	2758
	2759	#ifdef HAVE_XIM
	2760	typedef struct _GdkIC GdkIC;
	2761	typedef struct _GdkICAttr GdkICAttr;
	2762	#endif
	2763
	2764	/* Stand-ins for GTK types */
	2765	typedef struct _GtkWidget GtkWidget;
	2766	typedef struct _GtkRcStyle GtkRcStyle;
	2767	typedef struct _GtkAdjustment GtkAdjustment;
	2768	typedef struct _GtkList GtkList;
	2769	typedef struct _GtkToolbar GtkToolbar;
	2770	typedef struct _GtkTooltips GtkTooltips;
	2771	typedef struct _GtkNotebook GtkNotebook;
	2772	typedef struct _GtkNotebookPage GtkNotebookPage;
	2773	typedef struct _GtkAccelGroup GtkAccelGroup;
	2774	typedef struct _GtkItemFactory GtkItemFactory;
	2775	typedef struct _GtkSelectionData GtkSelectionData;
	2776	typedef struct _GtkTextBuffer GtkTextBuffer;
	2777	typedef struct _GtkRange GtkRange;
	2778
	2779	typedef GtkWidget *WXWidget;
	2780
	2781	#ifndef __WXGTK20__
	2782	#define GTK_OBJECT_GET_CLASS(object) (GTK_OBJECT(object)->klass)
	2783	#define GTK_CLASS_TYPE(klass) ((klass)->type)
	2784	#endif
	2785
	2786	#ifdef __WXGTK20__
	2787	#define G_DISABLE_DEPRECATED
	2788	#define PANGO_DISABLE_DEPRECATED
	2789	#define GDK_PIXBUF_DISABLE_DEPRECATED
	2790	#ifndef __VMS
	2791	/* GtkCombo is not defined on VMS if this is defined */
	2792	# define GTK_DISABLE_DEPRECATED
	2793	#endif
	2794	#endif
	2795
	2796	#endif /* __WXGTK__ */
	2797
	2798	#if defined(__WXGTK20__) \|\| (defined(__WXX11__) && wxUSE_UNICODE)
	2799	#define wxUSE_PANGO 1
	2800	#else
	2801	#define wxUSE_PANGO 0
	2802	#endif
	2803
	2804	#if wxUSE_PANGO
	2805	/* Stand-ins for Pango types */
	2806	typedef struct _PangoContext PangoContext;
	2807	typedef struct _PangoLayout PangoLayout;
	2808	typedef struct _PangoFontDescription PangoFontDescription;
	2809	#endif
	2810
	2811	#ifdef __WXMGL__
	2812	typedef struct window_t *WXWidget;
	2813	#endif /* MGL */
	2814
	2815	#ifdef __WXDFB__
	2816	/* DirectFB doesn't have the concept of non-TLW window, so use
	2817	something arbitrary */
	2818	typedef const void* WXWidget;
	2819	#endif /* DFB */
	2820
	2821	/* This is required because of clashing macros in windows.h, which may be */
	2822	/* included before or after wxWidgets classes, and therefore must be */
	2823	/* disabled here before any significant wxWidgets headers are included. */
	2824	#ifdef __WXMSW__
	2825	#ifdef GetClassInfo
	2826	#undef GetClassInfo
	2827	#endif
	2828
	2829	#ifdef GetClassName
	2830	#undef GetClassName
	2831	#endif
	2832
	2833	#ifdef DrawText
	2834	#undef DrawText
	2835	#endif
	2836
	2837	#ifdef GetCharWidth
	2838	#undef GetCharWidth
	2839	#endif
	2840
	2841	#ifdef StartDoc
	2842	#undef StartDoc
	2843	#endif
	2844
	2845	#ifdef FindWindow
	2846	#undef FindWindow
	2847	#endif
	2848
	2849	#ifdef FindResource
	2850	#undef FindResource
	2851	#endif
	2852	#endif
	2853	/* __WXMSW__ */
	2854
	2855	/* --------------------------------------------------------------------------- */
	2856	/* macro to define a class without copy ctor nor assignment operator */
	2857	/* --------------------------------------------------------------------------- */
	2858
	2859	#define DECLARE_NO_COPY_CLASS(classname) \
	2860	private: \
	2861	classname(const classname&); \
	2862	classname& operator=(const classname&);
	2863
	2864	#define DECLARE_NO_ASSIGN_CLASS(classname) \
	2865	private: \
	2866	classname& operator=(const classname&);
	2867
	2868	/* --------------------------------------------------------------------------- */
	2869	/* If a manifest is being automatically generated, add common controls 6 to it */
	2870	/* --------------------------------------------------------------------------- */
	2871
	2872	#if (!defined wxUSE_NO_MANIFEST \|\| wxUSE_NO_MANIFEST == 0 ) && \
	2873	( defined _MSC_FULL_VER && _MSC_FULL_VER >= 140040130 )
	2874
	2875	#define WX_CC_MANIFEST(cpu) \
	2876	"/manifestdependency:\"type='win32' \
	2877	name='Microsoft.Windows.Common-Controls' \
	2878	version='6.0.0.0' \
	2879	processorArchitecture='"cpu"' \
	2880	publicKeyToken='6595b64144ccf1df' \
	2881	language='*'\""
	2882
	2883	#if defined _M_IX86
	2884	#pragma comment(linker, WX_CC_MANIFEST("x86"))
	2885	#elif defined _M_X64
	2886	#pragma comment(linker, WX_CC_MANIFEST("amd64"))
	2887	#elif defined _M_IA64
	2888	#pragma comment(linker, WX_CC_MANIFEST("ia64"))
	2889	#else
	2890	#pragma comment(linker, WX_CC_MANIFEST("*"))
	2891	#endif
	2892
	2893	#endif /* !wxUSE_NO_MANIFEST && _MSC_FULL_VER >= 140040130 */
	2894
	2895	#endif
	2896	/* _WX_DEFS_H_ */