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

... / ...

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