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	/* ---------------------------------------------------------------------------- */
	1236	/* Window style flags */
	1237	/* ---------------------------------------------------------------------------- */
	1238
	1239	/*
	1240	* Values are chosen so they can be \|'ed in a bit list.
	1241	* Some styles are used across more than one group,
	1242	* so the values mustn't clash with others in the group.
	1243	* Otherwise, numbers can be reused across groups.
	1244	*
	1245	* From version 1.66:
	1246	* Window (cross-group) styles now take up the first half
	1247	* of the flag, and control-specific styles the
	1248	* second half.
	1249	*
	1250	*/
	1251
	1252	/*
	1253	* Window (Frame/dialog/subwindow/panel item) style flags
	1254	*/
	1255	#define wxVSCROLL 0x80000000
	1256	#define wxHSCROLL 0x40000000
	1257	#define wxCAPTION 0x20000000
	1258
	1259	/* New styles (border styles are now in their own enum) */
	1260	#define wxDOUBLE_BORDER wxBORDER_DOUBLE
	1261	#define wxSUNKEN_BORDER wxBORDER_SUNKEN
	1262	#define wxRAISED_BORDER wxBORDER_RAISED
	1263	#define wxBORDER wxBORDER_SIMPLE
	1264	#define wxSIMPLE_BORDER wxBORDER_SIMPLE
	1265	#define wxSTATIC_BORDER wxBORDER_STATIC
	1266	#define wxNO_BORDER wxBORDER_NONE
	1267
	1268	/* wxALWAYS_SHOW_SB: instead of hiding the scrollbar when it is not needed, */
	1269	/* disable it - but still show (see also wxLB_ALWAYS_SB style) */
	1270	/* */
	1271	/* NB: as this style is only supported by wxUniversal and wxMSW so far */
	1272	#define wxALWAYS_SHOW_SB 0x00800000
	1273
	1274	/* Clip children when painting, which reduces flicker in e.g. frames and */
	1275	/* splitter windows, but can't be used in a panel where a static box must be */
	1276	/* 'transparent' (panel paints the background for it) */
	1277	#define wxCLIP_CHILDREN 0x00400000
	1278
	1279	/* Note we're reusing the wxCAPTION style because we won't need captions */
	1280	/* for subwindows/controls */
	1281	#define wxCLIP_SIBLINGS 0x20000000
	1282
	1283	#define wxTRANSPARENT_WINDOW 0x00100000
	1284
	1285	/* Add this style to a panel to get tab traversal working outside of dialogs */
	1286	/* (on by default for wxPanel, wxDialog, wxScrolledWindow) */
	1287	#define wxTAB_TRAVERSAL 0x00080000
	1288
	1289	/* Add this style if the control wants to get all keyboard messages (under */
	1290	/* Windows, it won't normally get the dialog navigation key events) */
	1291	#define wxWANTS_CHARS 0x00040000
	1292
	1293	/* Make window retained (Motif only, see src/generic/scrolwing.cpp)
	1294	* This is non-zero only under wxMotif, to avoid a clash with wxPOPUP_WINDOW
	1295	* on other platforms
	1296	*/
	1297
	1298	#ifdef __WXMOTIF__
	1299	#define wxRETAINED 0x00020000
	1300	#else
	1301	#define wxRETAINED 0x00000000
	1302	#endif
	1303	#define wxBACKINGSTORE wxRETAINED
	1304
	1305	/* set this flag to create a special popup window: it will be always shown on */
	1306	/* top of other windows, will capture the mouse and will be dismissed when the */
	1307	/* mouse is clicked outside of it or if it loses focus in any other way */
	1308	#define wxPOPUP_WINDOW 0x00020000
	1309
	1310	/* force a full repaint when the window is resized (instead of repainting just */
	1311	/* the invalidated area) */
	1312	#define wxFULL_REPAINT_ON_RESIZE 0x00010000
	1313
	1314	/* obsolete: now this is the default behaviour */
	1315	/* */
	1316	/* don't invalidate the whole window (resulting in a PAINT event) when the */
	1317	/* window is resized (currently, makes sense for wxMSW only) */
	1318	#define wxNO_FULL_REPAINT_ON_RESIZE 0
	1319
	1320	/*
	1321	* Extra window style flags (use wxWS_EX prefix to make it clear that they
	1322	* should be passed to wxWindow::SetExtraStyle(), not SetWindowStyle())
	1323	*/
	1324
	1325	/* by default, TransferDataTo/FromWindow() only work on direct children of the */
	1326	/* window (compatible behaviour), set this flag to make them recursively */
	1327	/* descend into all subwindows */
	1328	#define wxWS_EX_VALIDATE_RECURSIVELY 0x00000001
	1329
	1330	/* wxCommandEvents and the objects of the derived classes are forwarded to the */
	1331	/* parent window and so on recursively by default. Using this flag for the */
	1332	/* given window allows to block this propagation at this window, i.e. prevent */
	1333	/* the events from being propagated further upwards. The dialogs have this */
	1334	/* flag on by default. */
	1335	#define wxWS_EX_BLOCK_EVENTS 0x00000002
	1336
	1337	/* don't use this window as an implicit parent for the other windows: this must */
	1338	/* be used with transient windows as otherwise there is the risk of creating a */
	1339	/* dialog/frame with this window as a parent which would lead to a crash if the */
	1340	/* parent is destroyed before the child */
	1341	#define wxWS_EX_TRANSIENT 0x00000004
	1342
	1343	/* don't paint the window background, we'll assume it will */
	1344	/* be done by a theming engine. This is not yet used but could */
	1345	/* possibly be made to work in the future, at least on Windows */
	1346	#define wxWS_EX_THEMED_BACKGROUND 0x00000008
	1347
	1348	/* this window should always process idle events */
	1349	#define wxWS_EX_PROCESS_IDLE 0x00000010
	1350
	1351	/* this window should always process UI update events */
	1352	#define wxWS_EX_PROCESS_UI_UPDATES 0x00000020
	1353
	1354	/* Use this style to add a context-sensitive help to the window (currently for */
	1355	/* Win32 only and it doesn't work if wxMINIMIZE_BOX or wxMAXIMIZE_BOX are used) */
	1356	#define wxFRAME_EX_CONTEXTHELP 0x00000004
	1357	#define wxDIALOG_EX_CONTEXTHELP 0x00000004
	1358
	1359	/* Draw the window in a metal theme on Mac */
	1360	#define wxFRAME_EX_METAL 0x00000040
	1361	#define wxDIALOG_EX_METAL 0x00000040
	1362
	1363	/* Create a window which is attachable to another top level window */
	1364	#define wxFRAME_DRAWER 0x0020
	1365
	1366	/*
	1367	* MDI parent frame style flags
	1368	* Can overlap with some of the above.
	1369	*/
	1370
	1371	#define wxFRAME_NO_WINDOW_MENU 0x0100
	1372
	1373	/*
	1374	* wxMenuBar style flags
	1375	*/
	1376	/* use native docking */
	1377	#define wxMB_DOCKABLE 0x0001
	1378
	1379	/*
	1380	* wxMenu style flags
	1381	*/
	1382	#define wxMENU_TEAROFF 0x0001
	1383
	1384	/*
	1385	* Apply to all panel items
	1386	*/
	1387	#define wxCOLOURED 0x0800
	1388	#define wxFIXED_LENGTH 0x0400
	1389
	1390	/*
	1391	* Styles for wxListBox
	1392	*/
	1393	#define wxLB_SORT 0x0010
	1394	#define wxLB_SINGLE 0x0020
	1395	#define wxLB_MULTIPLE 0x0040
	1396	#define wxLB_EXTENDED 0x0080
	1397	/* wxLB_OWNERDRAW is Windows-only */
	1398	#define wxLB_OWNERDRAW 0x0100
	1399	#define wxLB_NEEDED_SB 0x0200
	1400	#define wxLB_ALWAYS_SB 0x0400
	1401	#define wxLB_HSCROLL wxHSCROLL
	1402	/* always show an entire number of rows */
	1403	#define wxLB_INT_HEIGHT 0x0800
	1404
	1405	/* deprecated synonyms */
	1406	#define wxPROCESS_ENTER 0x0400 /* wxTE_PROCESS_ENTER */
	1407	#define wxPASSWORD 0x0800 /* wxTE_PASSWORD */
	1408
	1409	/*
	1410	* wxComboBox style flags
	1411	*/
	1412	#define wxCB_SIMPLE 0x0004
	1413	#define wxCB_SORT 0x0008
	1414	#define wxCB_READONLY 0x0010
	1415	#define wxCB_DROPDOWN 0x0020
	1416
	1417	/*
	1418	* wxRadioBox style flags
	1419	*/
	1420	/* should we number the items from left to right or from top to bottom in a 2d */
	1421	/* radiobox? */
	1422	#define wxRA_LEFTTORIGHT 0x0001
	1423	#define wxRA_TOPTOBOTTOM 0x0002
	1424
	1425	/* New, more intuitive names to specify majorDim argument */
	1426	#define wxRA_SPECIFY_COLS wxHORIZONTAL
	1427	#define wxRA_SPECIFY_ROWS wxVERTICAL
	1428
	1429	/* Old names for compatibility */
	1430	#define wxRA_HORIZONTAL wxHORIZONTAL
	1431	#define wxRA_VERTICAL wxVERTICAL
	1432	#define wxRA_USE_CHECKBOX 0x0010 /* alternative native subcontrols (wxPalmOS) */
	1433
	1434	/*
	1435	* wxRadioButton style flag
	1436	*/
	1437	#define wxRB_GROUP 0x0004
	1438	#define wxRB_SINGLE 0x0008
	1439	#define wxRB_USE_CHECKBOX 0x0010 /* alternative native control (wxPalmOS) */
	1440
	1441	/*
	1442	* wxSlider flags
	1443	*/
	1444	#define wxSL_HORIZONTAL wxHORIZONTAL /* 4 */
	1445	#define wxSL_VERTICAL wxVERTICAL /* 8 */
	1446	/* The next one is obsolete - use scroll events instead */
	1447	#define wxSL_NOTIFY_DRAG 0x0000
	1448	#define wxSL_TICKS 0x0010
	1449	#define wxSL_AUTOTICKS wxSL_TICKS /* we don't support manual ticks */
	1450	#define wxSL_LABELS 0x0020
	1451	#define wxSL_LEFT 0x0040
	1452	#define wxSL_TOP 0x0080
	1453	#define wxSL_RIGHT 0x0100
	1454	#define wxSL_BOTTOM 0x0200
	1455	#define wxSL_BOTH 0x0400
	1456	#define wxSL_SELRANGE 0x0800
	1457	#define wxSL_INVERSE 0x1000
	1458
	1459	/*
	1460	* wxScrollBar flags
	1461	*/
	1462	#define wxSB_HORIZONTAL wxHORIZONTAL
	1463	#define wxSB_VERTICAL wxVERTICAL
	1464
	1465	/*
	1466	* wxSpinButton flags.
	1467	* Note that a wxSpinCtrl is sometimes defined as
	1468	* a wxTextCtrl, and so the flags must be different
	1469	* from wxTextCtrl's.
	1470	*/
	1471	#define wxSP_HORIZONTAL wxHORIZONTAL /* 4 */
	1472	#define wxSP_VERTICAL wxVERTICAL /* 8 */
	1473	#define wxSP_ARROW_KEYS 0x1000
	1474	#define wxSP_WRAP 0x2000
	1475
	1476	/*
	1477	* wxNotebook flags
	1478	*/
	1479	#define wxNB_FIXEDWIDTH 0x0010
	1480	#define wxNB_TOP 0x0000 /* default */
	1481	#define wxNB_LEFT 0x0020
	1482	#define wxNB_RIGHT 0x0040
	1483	#define wxNB_BOTTOM 0x0080
	1484	#define wxNB_MULTILINE 0x0100
	1485	#define wxNB_NOPAGETHEME 0x0200
	1486	#define wxNB_FLAT 0x0400
	1487	#define wxNB_DEFAULT wxNB_TOP
	1488
	1489	/*
	1490	* wxListbook flags
	1491	*/
	1492	#define wxLB_DEFAULT 0x0
	1493	#define wxLB_TOP 0x1
	1494	#define wxLB_BOTTOM 0x2
	1495	#define wxLB_LEFT 0x4
	1496	#define wxLB_RIGHT 0x8
	1497	#define wxLB_ALIGN_MASK 0xf
	1498
	1499	/*
	1500	* wxChoicebook flags
	1501	*/
	1502	#define wxCHB_DEFAULT 0x0
	1503	#define wxCHB_TOP 0x1
	1504	#define wxCHB_BOTTOM 0x2
	1505	#define wxCHB_LEFT 0x4
	1506	#define wxCHB_RIGHT 0x8
	1507	#define wxCHB_ALIGN_MASK 0xf
	1508
	1509	/*
	1510	* wxTabCtrl flags
	1511	*/
	1512	#define wxTC_RIGHTJUSTIFY 0x0010
	1513	#define wxTC_FIXEDWIDTH 0x0020
	1514	#define wxTC_TOP 0x0000 /* default */
	1515	#define wxTC_LEFT 0x0020
	1516	#define wxTC_RIGHT 0x0040
	1517	#define wxTC_BOTTOM 0x0080
	1518	#define wxTC_MULTILINE wxNB_MULTILINE
	1519	#define wxTC_OWNERDRAW 0x0200
	1520
	1521	/*
	1522	* wxStatusBar95 flags
	1523	*/
	1524	#define wxST_SIZEGRIP 0x0010
	1525
	1526	/*
	1527	* wxStaticText flags
	1528	*/
	1529	#define wxST_NO_AUTORESIZE 0x0001
	1530
	1531	/*
	1532	* wxStaticBitmap flags
	1533	*/
	1534	#define wxBI_EXPAND wxEXPAND
	1535
	1536	/*
	1537	* wxStaticLine flags
	1538	*/
	1539	#define wxLI_HORIZONTAL wxHORIZONTAL
	1540	#define wxLI_VERTICAL wxVERTICAL
	1541
	1542	/*
	1543	* wxProgressDialog flags
	1544	*/
	1545	#define wxPD_CAN_ABORT 0x0001
	1546	#define wxPD_APP_MODAL 0x0002
	1547	#define wxPD_AUTO_HIDE 0x0004
	1548	#define wxPD_ELAPSED_TIME 0x0008
	1549	#define wxPD_ESTIMATED_TIME 0x0010
	1550	#define wxPD_SMOOTH 0x0020
	1551	#define wxPD_REMAINING_TIME 0x0040
	1552	#define wxPD_CAN_SKIP 0x0080
	1553
	1554	/*
	1555	* wxDirDialog styles
	1556	*/
	1557
	1558	#define wxDD_NEW_DIR_BUTTON 0x0080
	1559
	1560	/*
	1561	* extended dialog specifiers. these values are stored in a different
	1562	* flag and thus do not overlap with other style flags. note that these
	1563	* values do not correspond to the return values of the dialogs (for
	1564	* those values, look at the wxID_XXX defines).
	1565	*/
	1566
	1567	/* wxCENTRE already defined as 0x00000001 */
	1568	#define wxYES 0x00000002
	1569	#define wxOK 0x00000004
	1570	#define wxNO 0x00000008
	1571	#define wxYES_NO (wxYES \| wxNO)
	1572	#define wxCANCEL 0x00000010
	1573
	1574	#define wxYES_DEFAULT 0x00000000 /* has no effect (default) */
	1575	#define wxNO_DEFAULT 0x00000080
	1576
	1577	#define wxICON_EXCLAMATION 0x00000100
	1578	#define wxICON_HAND 0x00000200
	1579	#define wxICON_WARNING wxICON_EXCLAMATION
	1580	#define wxICON_ERROR wxICON_HAND
	1581	#define wxICON_QUESTION 0x00000400
	1582	#define wxICON_INFORMATION 0x00000800
	1583	#define wxICON_STOP wxICON_HAND
	1584	#define wxICON_ASTERISK wxICON_INFORMATION
	1585	#define wxICON_MASK (0x00000100\|0x00000200\|0x00000400\|0x00000800)
	1586
	1587	#define wxFORWARD 0x00001000
	1588	#define wxBACKWARD 0x00002000
	1589	#define wxRESET 0x00004000
	1590	#define wxHELP 0x00008000
	1591	#define wxMORE 0x00010000
	1592	#define wxSETUP 0x00020000
	1593
	1594	/*
	1595	* Background styles. See wxWindow::SetBackgroundStyle
	1596	*/
	1597
	1598	enum wxBackgroundStyle
	1599	{
	1600	wxBG_STYLE_SYSTEM,
	1601	wxBG_STYLE_COLOUR,
	1602	wxBG_STYLE_CUSTOM
	1603	};
	1604
	1605	/* ---------------------------------------------------------------------------- */
	1606	/* standard IDs */
	1607	/* ---------------------------------------------------------------------------- */
	1608
	1609	/* any id: means that we don't care about the id, whether when installing an */
	1610	/* event handler or when creating a new window */
	1611	enum
	1612	{
	1613	wxID_ANY = -1
	1614	};
	1615
	1616	/* id for a separator line in the menu (invalid for normal item) */
	1617	enum
	1618	{
	1619	wxID_SEPARATOR = -2
	1620	};
	1621
	1622	/* Standard menu IDs */
	1623	enum
	1624	{
	1625	wxID_LOWEST = 4999,
	1626
	1627	wxID_OPEN,
	1628	wxID_CLOSE,
	1629	wxID_NEW,
	1630	wxID_SAVE,
	1631	wxID_SAVEAS,
	1632	wxID_REVERT,
	1633	wxID_EXIT,
	1634	wxID_UNDO,
	1635	wxID_REDO,
	1636	wxID_HELP,
	1637	wxID_PRINT,
	1638	wxID_PRINT_SETUP,
	1639	wxID_PREVIEW,
	1640	wxID_ABOUT,
	1641	wxID_HELP_CONTENTS,
	1642	wxID_HELP_COMMANDS,
	1643	wxID_HELP_PROCEDURES,
	1644	wxID_HELP_CONTEXT,
	1645	wxID_CLOSE_ALL,
	1646	wxID_PREFERENCES ,
	1647
	1648	wxID_CUT = 5030,
	1649	wxID_COPY,
	1650	wxID_PASTE,
	1651	wxID_CLEAR,
	1652	wxID_FIND,
	1653	wxID_DUPLICATE,
	1654	wxID_SELECTALL,
	1655	wxID_DELETE,
	1656	wxID_REPLACE,
	1657	wxID_REPLACE_ALL,
	1658	wxID_PROPERTIES,
	1659
	1660	wxID_VIEW_DETAILS,
	1661	wxID_VIEW_LARGEICONS,
	1662	wxID_VIEW_SMALLICONS,
	1663	wxID_VIEW_LIST,
	1664	wxID_VIEW_SORTDATE,
	1665	wxID_VIEW_SORTNAME,
	1666	wxID_VIEW_SORTSIZE,
	1667	wxID_VIEW_SORTTYPE,
	1668
	1669	wxID_FILE1 = 5050,
	1670	wxID_FILE2,
	1671	wxID_FILE3,
	1672	wxID_FILE4,
	1673	wxID_FILE5,
	1674	wxID_FILE6,
	1675	wxID_FILE7,
	1676	wxID_FILE8,
	1677	wxID_FILE9,
	1678
	1679	/* Standard button and menu IDs */
	1680	wxID_OK = 5100,
	1681	wxID_CANCEL,
	1682	wxID_APPLY,
	1683	wxID_YES,
	1684	wxID_NO,
	1685	wxID_STATIC,
	1686	wxID_FORWARD,
	1687	wxID_BACKWARD,
	1688	wxID_DEFAULT,
	1689	wxID_MORE,
	1690	wxID_SETUP,
	1691	wxID_RESET,
	1692	wxID_CONTEXT_HELP,
	1693	wxID_YESTOALL,
	1694	wxID_NOTOALL,
	1695	wxID_ABORT,
	1696	wxID_RETRY,
	1697	wxID_IGNORE,
	1698	wxID_ADD,
	1699	wxID_REMOVE,
	1700
	1701	wxID_UP,
	1702	wxID_DOWN,
	1703	wxID_HOME,
	1704	wxID_REFRESH,
	1705	wxID_STOP,
	1706	wxID_INDEX,
	1707
	1708	wxID_BOLD,
	1709	wxID_ITALIC,
	1710	wxID_JUSTIFY_CENTER,
	1711	wxID_JUSTIFY_FILL,
	1712	wxID_JUSTIFY_RIGHT,
	1713	wxID_JUSTIFY_LEFT,
	1714	wxID_UNDERLINE,
	1715	wxID_INDENT,
	1716	wxID_UNINDENT,
	1717	wxID_ZOOM_100,
	1718	wxID_ZOOM_FIT,
	1719	wxID_ZOOM_IN,
	1720	wxID_ZOOM_OUT,
	1721	wxID_UNDELETE,
	1722	wxID_REVERT_TO_SAVED,
	1723
	1724	/* System menu IDs (used by wxUniv): */
	1725	wxID_SYSTEM_MENU = 5200,
	1726	wxID_CLOSE_FRAME,
	1727	wxID_MOVE_FRAME,
	1728	wxID_RESIZE_FRAME,
	1729	wxID_MAXIMIZE_FRAME,
	1730	wxID_ICONIZE_FRAME,
	1731	wxID_RESTORE_FRAME,
	1732
	1733	/* IDs used by generic file dialog (13 consecutive starting from this value) */
	1734	wxID_FILEDLGG = 5900,
	1735
	1736	wxID_HIGHEST = 5999
	1737	};
	1738
	1739	/* ---------------------------------------------------------------------------- */
	1740	/* other constants */
	1741	/* ---------------------------------------------------------------------------- */
	1742
	1743	/* menu and toolbar item kinds */
	1744	enum wxItemKind
	1745	{
	1746	wxITEM_SEPARATOR = -1,
	1747	wxITEM_NORMAL,
	1748	wxITEM_CHECK,
	1749	wxITEM_RADIO,
	1750	wxITEM_MAX
	1751	};
	1752
	1753	/* hit test results */
	1754	enum wxHitTest
	1755	{
	1756	wxHT_NOWHERE,
	1757
	1758	/* scrollbar */
	1759	wxHT_SCROLLBAR_FIRST = wxHT_NOWHERE,
	1760	wxHT_SCROLLBAR_ARROW_LINE_1, /* left or upper arrow to scroll by line */
	1761	wxHT_SCROLLBAR_ARROW_LINE_2, /* right or down */
	1762	wxHT_SCROLLBAR_ARROW_PAGE_1, /* left or upper arrow to scroll by page */
	1763	wxHT_SCROLLBAR_ARROW_PAGE_2, /* right or down */
	1764	wxHT_SCROLLBAR_THUMB, /* on the thumb */
	1765	wxHT_SCROLLBAR_BAR_1, /* bar to the left/above the thumb */
	1766	wxHT_SCROLLBAR_BAR_2, /* bar to the right/below the thumb */
	1767	wxHT_SCROLLBAR_LAST,
	1768
	1769	/* window */
	1770	wxHT_WINDOW_OUTSIDE, /* not in this window at all */
	1771	wxHT_WINDOW_INSIDE, /* in the client area */
	1772	wxHT_WINDOW_VERT_SCROLLBAR, /* on the vertical scrollbar */
	1773	wxHT_WINDOW_HORZ_SCROLLBAR, /* on the horizontal scrollbar */
	1774	wxHT_WINDOW_CORNER, /* on the corner between 2 scrollbars */
	1775
	1776	wxHT_MAX
	1777	};
	1778
	1779	/* ---------------------------------------------------------------------------- */
	1780	/* Possible SetSize flags */
	1781	/* ---------------------------------------------------------------------------- */
	1782
	1783	/* Use internally-calculated width if -1 */
	1784	#define wxSIZE_AUTO_WIDTH 0x0001
	1785	/* Use internally-calculated height if -1 */
	1786	#define wxSIZE_AUTO_HEIGHT 0x0002
	1787	/* Use internally-calculated width and height if each is -1 */
	1788	#define wxSIZE_AUTO (wxSIZE_AUTO_WIDTH\|wxSIZE_AUTO_HEIGHT)
	1789	/* Ignore missing (-1) dimensions (use existing). */
	1790	/* For readability only: test for wxSIZE_AUTO_WIDTH/HEIGHT in code. */
	1791	#define wxSIZE_USE_EXISTING 0x0000
	1792	/* Allow -1 as a valid position */
	1793	#define wxSIZE_ALLOW_MINUS_ONE 0x0004
	1794	/* Don't do parent client adjustments (for implementation only) */
	1795	#define wxSIZE_NO_ADJUSTMENTS 0x0008
	1796
	1797	/* ---------------------------------------------------------------------------- */
	1798	/* GDI descriptions */
	1799	/* ---------------------------------------------------------------------------- */
	1800
	1801	enum
	1802	{
	1803	/* Text font families */
	1804	wxDEFAULT = 70,
	1805	wxDECORATIVE,
	1806	wxROMAN,
	1807	wxSCRIPT,
	1808	wxSWISS,
	1809	wxMODERN,
	1810	wxTELETYPE, /* @@@@ */
	1811
	1812	/* Proportional or Fixed width fonts (not yet used) */
	1813	wxVARIABLE = 80,
	1814	wxFIXED,
	1815
	1816	wxNORMAL = 90,
	1817	wxLIGHT,
	1818	wxBOLD,
	1819	/* Also wxNORMAL for normal (non-italic text) */
	1820	wxITALIC,
	1821	wxSLANT,
	1822
	1823	/* Pen styles */
	1824	wxSOLID = 100,
	1825	wxDOT,
	1826	wxLONG_DASH,
	1827	wxSHORT_DASH,
	1828	wxDOT_DASH,
	1829	wxUSER_DASH,
	1830
	1831	wxTRANSPARENT,
	1832
	1833	/* Brush & Pen Stippling. Note that a stippled pen cannot be dashed!! */
	1834	/* Note also that stippling a Pen IS meaningfull, because a Line is */
	1835	wxSTIPPLE_MASK_OPAQUE, /* mask is used for blitting monochrome using text fore and back ground colors */
	1836	wxSTIPPLE_MASK, /* mask is used for masking areas in the stipple bitmap (TO DO) */
	1837	/* drawn with a Pen, and without any Brush -- and it can be stippled. */
	1838	wxSTIPPLE = 110,
	1839
	1840	wxBDIAGONAL_HATCH, /* In wxWidgets < 2.6 use WX_HATCH macro */
	1841	wxCROSSDIAG_HATCH, /* to verify these wx_HATCH are in style /
	1842	wxFDIAGONAL_HATCH, /* of wxBrush. In wxWidgets >= 2.6 use */
	1843	wxCROSS_HATCH, /* wxBrush::IsHatch() instead. */
	1844	wxHORIZONTAL_HATCH,
	1845	wxVERTICAL_HATCH,
	1846	wxFIRST_HATCH = wxBDIAGONAL_HATCH,
	1847	wxLAST_HATCH = wxVERTICAL_HATCH,
	1848
	1849	wxJOIN_BEVEL = 120,
	1850	wxJOIN_MITER,
	1851	wxJOIN_ROUND,
	1852
	1853	wxCAP_ROUND = 130,
	1854	wxCAP_PROJECTING,
	1855	wxCAP_BUTT
	1856	};
	1857
	1858	#if WXWIN_COMPATIBILITY_2_4
	1859	#define IS_HATCH(s) ((s)>=wxFIRST_HATCH && (s)<=wxLAST_HATCH)
	1860	#else
	1861	/* use wxBrush::IsHatch() instead thought wxMotif still uses it in src/motif/dcclient.cpp */
	1862	#endif
	1863
	1864	/* Logical ops */
	1865	typedef enum
	1866	{
	1867	wxCLEAR, wxROP_BLACK = wxCLEAR, wxBLIT_BLACKNESS = wxCLEAR, /* 0 */
	1868	wxXOR, wxROP_XORPEN = wxXOR, wxBLIT_SRCINVERT = wxXOR, /* src XOR dst */
	1869	wxINVERT, wxROP_NOT = wxINVERT, wxBLIT_DSTINVERT = wxINVERT, /* NOT dst */
	1870	wxOR_REVERSE, wxROP_MERGEPENNOT = wxOR_REVERSE, wxBLIT_00DD0228 = wxOR_REVERSE, /* src OR (NOT dst) */
	1871	wxAND_REVERSE, wxROP_MASKPENNOT = wxAND_REVERSE, wxBLIT_SRCERASE = wxAND_REVERSE, /* src AND (NOT dst) */
	1872	wxCOPY, wxROP_COPYPEN = wxCOPY, wxBLIT_SRCCOPY = wxCOPY, /* src */
	1873	wxAND, wxROP_MASKPEN = wxAND, wxBLIT_SRCAND = wxAND, /* src AND dst */
	1874	wxAND_INVERT, wxROP_MASKNOTPEN = wxAND_INVERT, wxBLIT_00220326 = wxAND_INVERT, /* (NOT src) AND dst */
	1875	wxNO_OP, wxROP_NOP = wxNO_OP, wxBLIT_00AA0029 = wxNO_OP, /* dst */
	1876	wxNOR, wxROP_NOTMERGEPEN = wxNOR, wxBLIT_NOTSRCERASE = wxNOR, /* (NOT src) AND (NOT dst) */
	1877	wxEQUIV, wxROP_NOTXORPEN = wxEQUIV, wxBLIT_00990066 = wxEQUIV, /* (NOT src) XOR dst */
	1878	wxSRC_INVERT, wxROP_NOTCOPYPEN = wxSRC_INVERT, wxBLIT_NOTSCRCOPY = wxSRC_INVERT, /* (NOT src) */
	1879	wxOR_INVERT, wxROP_MERGENOTPEN = wxOR_INVERT, wxBLIT_MERGEPAINT = wxOR_INVERT, /* (NOT src) OR dst */
	1880	wxNAND, wxROP_NOTMASKPEN = wxNAND, wxBLIT_007700E6 = wxNAND, /* (NOT src) OR (NOT dst) */
	1881	wxOR, wxROP_MERGEPEN = wxOR, wxBLIT_SRCPAINT = wxOR, /* src OR dst */
	1882	wxSET, wxROP_WHITE = wxSET, wxBLIT_WHITENESS = wxSET /* 1 */
	1883	} form_ops_t;
	1884
	1885	/* Flood styles */
	1886	enum
	1887	{
	1888	wxFLOOD_SURFACE = 1,
	1889	wxFLOOD_BORDER
	1890	};
	1891
	1892	/* Polygon filling mode */
	1893	enum
	1894	{
	1895	wxODDEVEN_RULE = 1,
	1896	wxWINDING_RULE
	1897	};
	1898
	1899	/* ToolPanel in wxFrame (VZ: unused?) */
	1900	enum
	1901	{
	1902	wxTOOL_TOP = 1,
	1903	wxTOOL_BOTTOM,
	1904	wxTOOL_LEFT,
	1905	wxTOOL_RIGHT
	1906	};
	1907
	1908	/* the values of the format constants should be the same as correspondign */
	1909	/* CF_XXX constants in Windows API */
	1910	enum wxDataFormatId
	1911	{
	1912	wxDF_INVALID = 0,
	1913	wxDF_TEXT = 1, /* CF_TEXT */
	1914	wxDF_BITMAP = 2, /* CF_BITMAP */
	1915	wxDF_METAFILE = 3, /* CF_METAFILEPICT */
	1916	wxDF_SYLK = 4,
	1917	wxDF_DIF = 5,
	1918	wxDF_TIFF = 6,
	1919	wxDF_OEMTEXT = 7, /* CF_OEMTEXT */
	1920	wxDF_DIB = 8, /* CF_DIB */
	1921	wxDF_PALETTE = 9,
	1922	wxDF_PENDATA = 10,
	1923	wxDF_RIFF = 11,
	1924	wxDF_WAVE = 12,
	1925	wxDF_UNICODETEXT = 13,
	1926	wxDF_ENHMETAFILE = 14,
	1927	wxDF_FILENAME = 15, /* CF_HDROP */
	1928	wxDF_LOCALE = 16,
	1929	wxDF_PRIVATE = 20,
	1930	wxDF_HTML = 30, /* Note: does not correspond to CF_ constant */
	1931	wxDF_MAX
	1932	};
	1933
	1934	/* Virtual keycodes */
	1935	enum wxKeyCode
	1936	{
	1937	WXK_BACK = 8,
	1938	WXK_TAB = 9,
	1939	WXK_RETURN = 13,
	1940	WXK_ESCAPE = 27,
	1941	WXK_SPACE = 32,
	1942	WXK_DELETE = 127,
	1943
	1944	/* These are, by design, not compatible with unicode characters.
	1945	If you want to get a unicode character from a key event, use
	1946	wxKeyEvent::GetUnicodeKey instead. */
	1947	WXK_START = 300,
	1948	WXK_LBUTTON,
	1949	WXK_RBUTTON,
	1950	WXK_CANCEL,
	1951	WXK_MBUTTON,
	1952	WXK_CLEAR,
	1953	WXK_SHIFT,
	1954	WXK_ALT,
	1955	WXK_CONTROL,
	1956	WXK_MENU,
	1957	WXK_PAUSE,
	1958	WXK_CAPITAL,
	1959	WXK_PRIOR, /* Page up */
	1960	WXK_NEXT, /* Page down */
	1961	WXK_END,
	1962	WXK_HOME,
	1963	WXK_LEFT,
	1964	WXK_UP,
	1965	WXK_RIGHT,
	1966	WXK_DOWN,
	1967	WXK_SELECT,
	1968	WXK_PRINT,
	1969	WXK_EXECUTE,
	1970	WXK_SNAPSHOT,
	1971	WXK_INSERT,
	1972	WXK_HELP,
	1973	WXK_NUMPAD0,
	1974	WXK_NUMPAD1,
	1975	WXK_NUMPAD2,
	1976	WXK_NUMPAD3,
	1977	WXK_NUMPAD4,
	1978	WXK_NUMPAD5,
	1979	WXK_NUMPAD6,
	1980	WXK_NUMPAD7,
	1981	WXK_NUMPAD8,
	1982	WXK_NUMPAD9,
	1983	WXK_MULTIPLY,
	1984	WXK_ADD,
	1985	WXK_SEPARATOR,
	1986	WXK_SUBTRACT,
	1987	WXK_DECIMAL,
	1988	WXK_DIVIDE,
	1989	WXK_F1,
	1990	WXK_F2,
	1991	WXK_F3,
	1992	WXK_F4,
	1993	WXK_F5,
	1994	WXK_F6,
	1995	WXK_F7,
	1996	WXK_F8,
	1997	WXK_F9,
	1998	WXK_F10,
	1999	WXK_F11,
	2000	WXK_F12,
	2001	WXK_F13,
	2002	WXK_F14,
	2003	WXK_F15,
	2004	WXK_F16,
	2005	WXK_F17,
	2006	WXK_F18,
	2007	WXK_F19,
	2008	WXK_F20,
	2009	WXK_F21,
	2010	WXK_F22,
	2011	WXK_F23,
	2012	WXK_F24,
	2013	WXK_NUMLOCK,
	2014	WXK_SCROLL,
	2015	WXK_PAGEUP,
	2016	WXK_PAGEDOWN,
	2017
	2018	WXK_NUMPAD_SPACE,
	2019	WXK_NUMPAD_TAB,
	2020	WXK_NUMPAD_ENTER,
	2021	WXK_NUMPAD_F1,
	2022	WXK_NUMPAD_F2,
	2023	WXK_NUMPAD_F3,
	2024	WXK_NUMPAD_F4,
	2025	WXK_NUMPAD_HOME,
	2026	WXK_NUMPAD_LEFT,
	2027	WXK_NUMPAD_UP,
	2028	WXK_NUMPAD_RIGHT,
	2029	WXK_NUMPAD_DOWN,
	2030	WXK_NUMPAD_PRIOR,
	2031	WXK_NUMPAD_PAGEUP,
	2032	WXK_NUMPAD_NEXT,
	2033	WXK_NUMPAD_PAGEDOWN,
	2034	WXK_NUMPAD_END,
	2035	WXK_NUMPAD_BEGIN,
	2036	WXK_NUMPAD_INSERT,
	2037	WXK_NUMPAD_DELETE,
	2038	WXK_NUMPAD_EQUAL,
	2039	WXK_NUMPAD_MULTIPLY,
	2040	WXK_NUMPAD_ADD,
	2041	WXK_NUMPAD_SEPARATOR,
	2042	WXK_NUMPAD_SUBTRACT,
	2043	WXK_NUMPAD_DECIMAL,
	2044	WXK_NUMPAD_DIVIDE,
	2045
	2046	WXK_WINDOWS_LEFT,
	2047	WXK_WINDOWS_RIGHT,
	2048	WXK_WINDOWS_MENU ,
	2049	WXK_COMMAND,
	2050
	2051	/* Hardware-specific buttons */
	2052	WXK_SPECIAL1 = 193,
	2053	WXK_SPECIAL2,
	2054	WXK_SPECIAL3,
	2055	WXK_SPECIAL4,
	2056	WXK_SPECIAL5,
	2057	WXK_SPECIAL6,
	2058	WXK_SPECIAL7,
	2059	WXK_SPECIAL8,
	2060	WXK_SPECIAL9,
	2061	WXK_SPECIAL10,
	2062	WXK_SPECIAL11,
	2063	WXK_SPECIAL12,
	2064	WXK_SPECIAL13,
	2065	WXK_SPECIAL14,
	2066	WXK_SPECIAL15,
	2067	WXK_SPECIAL16,
	2068	WXK_SPECIAL17,
	2069	WXK_SPECIAL18,
	2070	WXK_SPECIAL19,
	2071	WXK_SPECIAL20
	2072	};
	2073
	2074	#if wxUSE_HOTKEY
	2075	enum wxHotkeyModifier
	2076	{
	2077	wxMOD_NONE = 0,
	2078	wxMOD_ALT = 1,
	2079	wxMOD_CONTROL = 2,
	2080	wxMOD_SHIFT = 4,
	2081	wxMOD_WIN = 8
	2082	};
	2083	#endif
	2084
	2085	/* Mapping modes (same values as used by Windows, don't change) */
	2086	enum
	2087	{
	2088	wxMM_TEXT = 1,
	2089	wxMM_LOMETRIC,
	2090	wxMM_HIMETRIC,
	2091	wxMM_LOENGLISH,
	2092	wxMM_HIENGLISH,
	2093	wxMM_TWIPS,
	2094	wxMM_ISOTROPIC,
	2095	wxMM_ANISOTROPIC,
	2096	wxMM_POINTS,
	2097	wxMM_METRIC
	2098	};
	2099
	2100	/* Shortcut for easier dialog-unit-to-pixel conversion */
	2101	#define wxDLG_UNIT(parent, pt) parent->ConvertDialogToPixels(pt)
	2102
	2103	/* Paper types */
	2104	typedef enum
	2105	{
	2106	wxPAPER_NONE, /* Use specific dimensions */
	2107	wxPAPER_LETTER, /* Letter, 8 1/2 by 11 inches */
	2108	wxPAPER_LEGAL, /* Legal, 8 1/2 by 14 inches */
	2109	wxPAPER_A4, /* A4 Sheet, 210 by 297 millimeters */
	2110	wxPAPER_CSHEET, /* C Sheet, 17 by 22 inches */
	2111	wxPAPER_DSHEET, /* D Sheet, 22 by 34 inches */
	2112	wxPAPER_ESHEET, /* E Sheet, 34 by 44 inches */
	2113	wxPAPER_LETTERSMALL, /* Letter Small, 8 1/2 by 11 inches */
	2114	wxPAPER_TABLOID, /* Tabloid, 11 by 17 inches */
	2115	wxPAPER_LEDGER, /* Ledger, 17 by 11 inches */
	2116	wxPAPER_STATEMENT, /* Statement, 5 1/2 by 8 1/2 inches */
	2117	wxPAPER_EXECUTIVE, /* Executive, 7 1/4 by 10 1/2 inches */
	2118	wxPAPER_A3, /* A3 sheet, 297 by 420 millimeters */
	2119	wxPAPER_A4SMALL, /* A4 small sheet, 210 by 297 millimeters */
	2120	wxPAPER_A5, /* A5 sheet, 148 by 210 millimeters */
	2121	wxPAPER_B4, /* B4 sheet, 250 by 354 millimeters */
	2122	wxPAPER_B5, /* B5 sheet, 182-by-257-millimeter paper */
	2123	wxPAPER_FOLIO, /* Folio, 8-1/2-by-13-inch paper */
	2124	wxPAPER_QUARTO, /* Quarto, 215-by-275-millimeter paper */
	2125	wxPAPER_10X14, /* 10-by-14-inch sheet */
	2126	wxPAPER_11X17, /* 11-by-17-inch sheet */
	2127	wxPAPER_NOTE, /* Note, 8 1/2 by 11 inches */
	2128	wxPAPER_ENV_9, /* #9 Envelope, 3 7/8 by 8 7/8 inches */
	2129	wxPAPER_ENV_10, /* #10 Envelope, 4 1/8 by 9 1/2 inches */
	2130	wxPAPER_ENV_11, /* #11 Envelope, 4 1/2 by 10 3/8 inches */
	2131	wxPAPER_ENV_12, /* #12 Envelope, 4 3/4 by 11 inches */
	2132	wxPAPER_ENV_14, /* #14 Envelope, 5 by 11 1/2 inches */
	2133	wxPAPER_ENV_DL, /* DL Envelope, 110 by 220 millimeters */
	2134	wxPAPER_ENV_C5, /* C5 Envelope, 162 by 229 millimeters */
	2135	wxPAPER_ENV_C3, /* C3 Envelope, 324 by 458 millimeters */
	2136	wxPAPER_ENV_C4, /* C4 Envelope, 229 by 324 millimeters */
	2137	wxPAPER_ENV_C6, /* C6 Envelope, 114 by 162 millimeters */
	2138	wxPAPER_ENV_C65, /* C65 Envelope, 114 by 229 millimeters */
	2139	wxPAPER_ENV_B4, /* B4 Envelope, 250 by 353 millimeters */
	2140	wxPAPER_ENV_B5, /* B5 Envelope, 176 by 250 millimeters */
	2141	wxPAPER_ENV_B6, /* B6 Envelope, 176 by 125 millimeters */
	2142	wxPAPER_ENV_ITALY, /* Italy Envelope, 110 by 230 millimeters */
	2143	wxPAPER_ENV_MONARCH, /* Monarch Envelope, 3 7/8 by 7 1/2 inches */
	2144	wxPAPER_ENV_PERSONAL, /* 6 3/4 Envelope, 3 5/8 by 6 1/2 inches */
	2145	wxPAPER_FANFOLD_US, /* US Std Fanfold, 14 7/8 by 11 inches */
	2146	wxPAPER_FANFOLD_STD_GERMAN, /* German Std Fanfold, 8 1/2 by 12 inches */
	2147	wxPAPER_FANFOLD_LGL_GERMAN, /* German Legal Fanfold, 8 1/2 by 13 inches */
	2148
	2149	wxPAPER_ISO_B4, /* B4 (ISO) 250 x 353 mm */
	2150	wxPAPER_JAPANESE_POSTCARD, /* Japanese Postcard 100 x 148 mm */
	2151	wxPAPER_9X11, /* 9 x 11 in */
	2152	wxPAPER_10X11, /* 10 x 11 in */
	2153	wxPAPER_15X11, /* 15 x 11 in */
	2154	wxPAPER_ENV_INVITE, /* Envelope Invite 220 x 220 mm */
	2155	wxPAPER_LETTER_EXTRA, /* Letter Extra 9 \275 x 12 in */
	2156	wxPAPER_LEGAL_EXTRA, /* Legal Extra 9 \275 x 15 in */
	2157	wxPAPER_TABLOID_EXTRA, /* Tabloid Extra 11.69 x 18 in */
	2158	wxPAPER_A4_EXTRA, /* A4 Extra 9.27 x 12.69 in */
	2159	wxPAPER_LETTER_TRANSVERSE, /* Letter Transverse 8 \275 x 11 in */
	2160	wxPAPER_A4_TRANSVERSE, /* A4 Transverse 210 x 297 mm */
	2161	wxPAPER_LETTER_EXTRA_TRANSVERSE, /* Letter Extra Transverse 9\275 x 12 in */
	2162	wxPAPER_A_PLUS, /* SuperA/SuperA/A4 227 x 356 mm */
	2163	wxPAPER_B_PLUS, /* SuperB/SuperB/A3 305 x 487 mm */
	2164	wxPAPER_LETTER_PLUS, /* Letter Plus 8.5 x 12.69 in */
	2165	wxPAPER_A4_PLUS, /* A4 Plus 210 x 330 mm */
	2166	wxPAPER_A5_TRANSVERSE, /* A5 Transverse 148 x 210 mm */
	2167	wxPAPER_B5_TRANSVERSE, /* B5 (JIS) Transverse 182 x 257 mm */
	2168	wxPAPER_A3_EXTRA, /* A3 Extra 322 x 445 mm */
	2169	wxPAPER_A5_EXTRA, /* A5 Extra 174 x 235 mm */
	2170	wxPAPER_B5_EXTRA, /* B5 (ISO) Extra 201 x 276 mm */
	2171	wxPAPER_A2, /* A2 420 x 594 mm */
	2172	wxPAPER_A3_TRANSVERSE, /* A3 Transverse 297 x 420 mm */
	2173	wxPAPER_A3_EXTRA_TRANSVERSE /* A3 Extra Transverse 322 x 445 mm */
	2174
	2175	} wxPaperSize;
	2176
	2177	/* Printing orientation */
	2178	#ifndef wxPORTRAIT
	2179	#define wxPORTRAIT 1
	2180	#define wxLANDSCAPE 2
	2181	#endif
	2182
	2183	/* Duplex printing modes
	2184	*/
	2185
	2186	enum wxDuplexMode
	2187	{
	2188	wxDUPLEX_SIMPLEX, /* Non-duplex */
	2189	wxDUPLEX_HORIZONTAL,
	2190	wxDUPLEX_VERTICAL
	2191	};
	2192
	2193	/* Print quality.
	2194	*/
	2195
	2196	#define wxPRINT_QUALITY_HIGH -1
	2197	#define wxPRINT_QUALITY_MEDIUM -2
	2198	#define wxPRINT_QUALITY_LOW -3
	2199	#define wxPRINT_QUALITY_DRAFT -4
	2200
	2201	typedef int wxPrintQuality;
	2202
	2203	/* Print mode (currently PostScript only)
	2204	*/
	2205
	2206	enum wxPrintMode
	2207	{
	2208	wxPRINT_MODE_NONE = 0,
	2209	wxPRINT_MODE_PREVIEW = 1, /* Preview in external application */
	2210	wxPRINT_MODE_FILE = 2, /* Print to file */
	2211	wxPRINT_MODE_PRINTER = 3, /* Send to printer */
	2212	wxPRINT_MODE_STREAM = 4 /* Send postscript data into a stream */
	2213	};
	2214
	2215	/* ---------------------------------------------------------------------------- */
	2216	/* UpdateWindowUI flags */
	2217	/* ---------------------------------------------------------------------------- */
	2218
	2219	enum wxUpdateUI
	2220	{
	2221	wxUPDATE_UI_NONE = 0x0000,
	2222	wxUPDATE_UI_RECURSE = 0x0001,
	2223	wxUPDATE_UI_FROMIDLE = 0x0002 /* Invoked from On(Internal)Idle */
	2224	};
	2225
	2226	/* ---------------------------------------------------------------------------- */
	2227	/* miscellaneous */
	2228	/* ---------------------------------------------------------------------------- */
	2229
	2230	/* define this macro if font handling is done using the X font names */
	2231	#if (defined(__WXGTK__) && !defined(__WXGTK20__)) \|\| defined(__X__)
	2232	#define _WX_X_FONTLIKE
	2233	#endif
	2234
	2235	/* macro to specify "All Files" on different platforms */
	2236	#if defined(__WXMSW__) \|\| defined(__WXPM__)
	2237	# define wxALL_FILES_PATTERN wxT(".")
	2238	# define wxALL_FILES gettext_noop("All files (.)\|.")
	2239	#else
	2240	# define wxALL_FILES_PATTERN wxT("*")
	2241	# define wxALL_FILES gettext_noop("All files ()\|")
	2242	#endif
	2243
	2244	/* --------------------------------------------------------------------------- */
	2245	/* macros that enable wxWidgets apps to be compiled in absence of the */
	2246	/* sytem headers, although some platform specific types are used in the */
	2247	/* platform specific (implementation) parts of the headers */
	2248	/* --------------------------------------------------------------------------- */
	2249
	2250	#ifdef __WXMAC__
	2251
	2252	#define WX_OPAQUE_TYPE( name ) struct wxOpaque##name
	2253
	2254	typedef unsigned char WXCOLORREF[6];
	2255	typedef void* WXCGIMAGEREF;
	2256	typedef void* WXHBITMAP;
	2257	typedef void* WXHCURSOR;
	2258	typedef void* WXHRGN;
	2259	typedef void* WXRECTPTR;
	2260	typedef void* WXPOINTPTR;
	2261	typedef void* WXHWND;
	2262	typedef void* WXEVENTREF;
	2263	typedef void* WXEVENTHANDLERREF;
	2264	typedef void* WXEVENTHANDLERCALLREF;
	2265	typedef void* WXAPPLEEVENTREF;
	2266	typedef void* WXHDC;
	2267	typedef void* WXHMENU;
	2268	typedef unsigned int WXUINT;
	2269	typedef unsigned long WXDWORD;
	2270	typedef unsigned short WXWORD;
	2271
	2272	typedef WX_OPAQUE_TYPE(CIconHandle ) * WXHICON ;
	2273	typedef WX_OPAQUE_TYPE(PicHandle ) * WXHMETAFILE ;
	2274
	2275
	2276	/* typedef void* WXWidget; */
	2277	/* typedef void* WXWindow; */
	2278	typedef WX_OPAQUE_TYPE(ControlRef ) * WXWidget ;
	2279	typedef WX_OPAQUE_TYPE(WindowRef) * WXWindow ;
	2280	typedef void* WXDisplay;
	2281
	2282	/* typedef WindowPtr WXHWND; */
	2283	/* typedef Handle WXHANDLE; */
	2284	/* typedef CIconHandle WXHICON; */
	2285	/* typedef unsigned long WXHFONT; */
	2286	/* typedef MenuHandle WXHMENU; */
	2287	/* typedef unsigned long WXHPEN; */
	2288	/* typedef unsigned long WXHBRUSH; */
	2289	/* typedef unsigned long WXHPALETTE; */
	2290	/* typedef CursHandle WXHCURSOR; */
	2291	/* typedef RgnHandle WXHRGN; */
	2292	/* typedef unsigned long WXHACCEL; */
	2293	/* typedef unsigned long WXHINSTANCE; */
	2294	/* typedef unsigned long WXHIMAGELIST; */
	2295	/* typedef unsigned long WXHGLOBAL; */
	2296	/* typedef GrafPtr WXHDC; */
	2297	/* typedef unsigned int WXWPARAM; */
	2298	/* typedef long WXLPARAM; */
	2299	/* typedef void * WXRGNDATA; */
	2300	/* typedef void * WXMSG; */
	2301	/* typedef unsigned long WXHCONV; */
	2302	/* typedef unsigned long WXHKEY; */
	2303	/* typedef void * WXDRAWITEMSTRUCT; */
	2304	/* typedef void * WXMEASUREITEMSTRUCT; */
	2305	/* typedef void * WXLPCREATESTRUCT; */
	2306	/* typedef int (WXFARPROC)(); /
	2307
	2308	/* typedef WindowPtr WXWindow; */
	2309	/* typedef ControlHandle WXWidget; */
	2310
	2311	#endif
	2312
	2313	#ifdef __WXCOCOA__
	2314
	2315	/* NOTE: This ought to work with other compilers too, but I'm being cautious */
	2316	#if (defined(__GNUC__) && defined(__APPLE__)) \|\| defined(__MWERKS__)
	2317	/* It's desirable to have type safety for Objective-C(++) code as it does
	2318	at least catch typos of method names among other things. However, it
	2319	is not possible to declare an Objective-C class from plain old C or C++
	2320	code. Furthermore, because of C++ name mangling, the type name must
	2321	be the same for both C++ and Objective-C++ code. Therefore, we define
	2322	what should be a pointer to an Objective-C class as a pointer to a plain
	2323	old C struct with the same name. Unfortunately, because the compiler
	2324	does not see a struct as an Objective-C class we cannot declare it
	2325	as a struct in Objective-C(++) mode.
	2326	*/
	2327	#if defined(__OBJC__)
	2328	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2329	@class klass; \
	2330	typedef klass *WX_##klass
	2331	#else /* not defined(__OBJC__) */
	2332	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2333	typedef struct klass *WX_##klass
	2334	#endif /* defined(__OBJC__) */
	2335
	2336	#else /* not Apple's GNU or CodeWarrior */
	2337	#warning "Objective-C types will not be checked by the compiler."
	2338	/* NOTE: typedef struct objc_object id; /
	2339	/* IOW, we're declaring these using the id type without using that name, */
	2340	/* since "id" is used extensively not only within wxWidgets itself, but */
	2341	/* also in wxWidgets application code. The following works fine when */
	2342	/* compiling C(++) code, and works without typesafety for Obj-C(++) code */
	2343	#define DECLARE_WXCOCOA_OBJC_CLASS(klass) \
	2344	typedef struct objc_object *WX_##klass
	2345
	2346	#endif /* (defined(__GNUC__) && defined(__APPLE__)) \|\| defined(__MWERKS__) */
	2347
	2348	DECLARE_WXCOCOA_OBJC_CLASS(NSApplication);
	2349	DECLARE_WXCOCOA_OBJC_CLASS(NSBitmapImageRep);
	2350	DECLARE_WXCOCOA_OBJC_CLASS(NSBox);
	2351	DECLARE_WXCOCOA_OBJC_CLASS(NSButton);
	2352	DECLARE_WXCOCOA_OBJC_CLASS(NSColor);
	2353	DECLARE_WXCOCOA_OBJC_CLASS(NSColorPanel);
	2354	DECLARE_WXCOCOA_OBJC_CLASS(NSControl);
	2355	DECLARE_WXCOCOA_OBJC_CLASS(NSCursor);
	2356	DECLARE_WXCOCOA_OBJC_CLASS(NSEvent);
	2357	DECLARE_WXCOCOA_OBJC_CLASS(NSFontPanel);
	2358	DECLARE_WXCOCOA_OBJC_CLASS(NSImage);
	2359	DECLARE_WXCOCOA_OBJC_CLASS(NSLayoutManager);
	2360	DECLARE_WXCOCOA_OBJC_CLASS(NSMenu);
	2361	DECLARE_WXCOCOA_OBJC_CLASS(NSMenuExtra);
	2362	DECLARE_WXCOCOA_OBJC_CLASS(NSMenuItem);
	2363	DECLARE_WXCOCOA_OBJC_CLASS(NSMutableArray);
	2364	DECLARE_WXCOCOA_OBJC_CLASS(NSNotification);
	2365	DECLARE_WXCOCOA_OBJC_CLASS(NSObject);
	2366	DECLARE_WXCOCOA_OBJC_CLASS(NSPanel);
	2367	DECLARE_WXCOCOA_OBJC_CLASS(NSScrollView);
	2368	DECLARE_WXCOCOA_OBJC_CLASS(NSSound);
	2369	DECLARE_WXCOCOA_OBJC_CLASS(NSStatusItem);
	2370	DECLARE_WXCOCOA_OBJC_CLASS(NSTableColumn);
	2371	DECLARE_WXCOCOA_OBJC_CLASS(NSTableView);
	2372	DECLARE_WXCOCOA_OBJC_CLASS(NSTextContainer);
	2373	DECLARE_WXCOCOA_OBJC_CLASS(NSTextField);
	2374	DECLARE_WXCOCOA_OBJC_CLASS(NSTextStorage);
	2375	DECLARE_WXCOCOA_OBJC_CLASS(NSThread);
	2376	DECLARE_WXCOCOA_OBJC_CLASS(NSWindow);
	2377	DECLARE_WXCOCOA_OBJC_CLASS(NSView);
	2378	typedef WX_NSView WXWidget; /* wxWidgets BASE definition */
	2379	#endif /* __WXCOCOA__ */
	2380
	2381	#if defined(__WXPALMOS__)
	2382
	2383	typedef void * WXHANDLE;
	2384	typedef void * WXHICON;
	2385	typedef void * WXHFONT;
	2386	typedef void * WXHMENU;
	2387	typedef void * WXHPEN;
	2388	typedef void * WXHBRUSH;
	2389	typedef void * WXHPALETTE;
	2390	typedef void * WXHCURSOR;
	2391	typedef void * WXHRGN;
	2392	typedef void * WXHACCEL;
	2393	typedef void * WXHINSTANCE;
	2394	typedef void * WXHBITMAP;
	2395	typedef void * WXHIMAGELIST;
	2396	typedef void * WXHGLOBAL;
	2397	typedef void * WXHDC;
	2398	typedef unsigned int WXUINT;
	2399	typedef unsigned long WXDWORD;
	2400	typedef unsigned short WXWORD;
	2401
	2402	typedef unsigned long WXCOLORREF;
	2403	typedef struct tagMSG WXMSG;
	2404
	2405	typedef WinHandle WXWINHANDLE;
	2406	typedef WXWINHANDLE WXWidget;
	2407
	2408	#endif /* __WXPALMOS__ */
	2409
	2410
	2411	#if defined(__WXMSW__)
	2412
	2413	/* the keywords needed for WinMain() declaration */
	2414	#ifndef WXFAR
	2415	# define WXFAR
	2416	#endif
	2417
	2418	/* Stand-ins for Windows types to avoid #including all of windows.h */
	2419	typedef void * WXHWND;
	2420	typedef void * WXHANDLE;
	2421	typedef void * WXHICON;
	2422	typedef void * WXHFONT;
	2423	typedef void * WXHMENU;
	2424	typedef void * WXHPEN;
	2425	typedef void * WXHBRUSH;
	2426	typedef void * WXHPALETTE;
	2427	typedef void * WXHCURSOR;
	2428	typedef void * WXHRGN;
	2429	typedef void * WXHACCEL;
	2430	typedef void WXFAR * WXHINSTANCE;
	2431	typedef void * WXHBITMAP;
	2432	typedef void * WXHIMAGELIST;
	2433	typedef void * WXHGLOBAL;
	2434	typedef void * WXHDC;
	2435	typedef unsigned int WXUINT;
	2436	typedef unsigned long WXDWORD;
	2437	typedef unsigned short WXWORD;
	2438
	2439	typedef unsigned long WXCOLORREF;
	2440	typedef void * WXRGNDATA;
	2441	typedef struct tagMSG WXMSG;
	2442	typedef void * WXHCONV;
	2443	typedef void * WXHKEY;
	2444	typedef void * WXHTREEITEM;
	2445
	2446	typedef void * WXDRAWITEMSTRUCT;
	2447	typedef void * WXMEASUREITEMSTRUCT;
	2448	typedef void * WXLPCREATESTRUCT;
	2449
	2450	typedef WXHWND WXWidget;
	2451
	2452	#ifdef __WIN64__
	2453	typedef unsigned __int64 WXWPARAM;
	2454	typedef __int64 WXLPARAM;
	2455	typedef __int64 WXLRESULT;
	2456	#else
	2457	typedef unsigned int WXWPARAM;
	2458	typedef long WXLPARAM;
	2459	typedef long WXLRESULT;
	2460	#endif
	2461
	2462	#if !defined(__WIN32__) \|\| defined(__GNUWIN32__) \|\| defined(__WXMICROWIN__)
	2463	typedef int (*WXFARPROC)();
	2464	#else
	2465	typedef int (__stdcall *WXFARPROC)();
	2466	#endif
	2467	#endif /* __WXMSW__ */
	2468
	2469
	2470	#if defined(__WXPM__) \|\| defined(__EMX__)
	2471	#ifdef __WXPM__
	2472	/* Stand-ins for OS/2 types, to avoid #including all of os2.h */
	2473	typedef unsigned long WXHWND;
	2474	typedef unsigned long WXHANDLE;
	2475	typedef unsigned long WXHICON;
	2476	typedef unsigned long WXHFONT;
	2477	typedef unsigned long WXHMENU;
	2478	typedef unsigned long WXHPEN;
	2479	typedef unsigned long WXHBRUSH;
	2480	typedef unsigned long WXHPALETTE;
	2481	typedef unsigned long WXHCURSOR;
	2482	typedef unsigned long WXHRGN;
	2483	typedef unsigned long WXHACCEL;
	2484	typedef unsigned long WXHBITMAP;
	2485	typedef unsigned long WXHDC;
	2486	typedef unsigned int WXUINT;
	2487	typedef unsigned long WXDWORD;
	2488	typedef unsigned short WXWORD;
	2489
	2490	typedef unsigned long WXCOLORREF;
	2491	typedef void * WXMSG;
	2492	typedef unsigned long WXHTREEITEM;
	2493
	2494	typedef void * WXDRAWITEMSTRUCT;
	2495	typedef void * WXMEASUREITEMSTRUCT;
	2496	typedef void * WXLPCREATESTRUCT;
	2497
	2498	typedef WXHWND WXWidget;
	2499	#endif
	2500	#ifdef __EMX__
	2501	/* Need a well-known type for WXFARPROC
	2502	below. MPARAM is typedef'ed too late. */
	2503	#define WXWPARAM void *
	2504	#define WXLPARAM void *
	2505	#else
	2506	#define WXWPARAM MPARAM
	2507	#define WXLPARAM MPARAM
	2508	#endif
	2509	#define RECT RECTL
	2510	#define LOGFONT FATTRS
	2511	#define LOWORD SHORT1FROMMP
	2512	#define HIWORD SHORT2FROMMP
	2513
	2514	typedef unsigned long WXMPARAM;
	2515	typedef unsigned long WXMSGID;
	2516	typedef void* WXRESULT;
	2517	/* typedef int (WXFARPROC)(); /
	2518	/* some windows handles not defined by PM */
	2519	typedef unsigned long HANDLE;
	2520	typedef unsigned long HICON;
	2521	typedef unsigned long HFONT;
	2522	typedef unsigned long HMENU;
	2523	typedef unsigned long HPEN;
	2524	typedef unsigned long HBRUSH;
	2525	typedef unsigned long HPALETTE;
	2526	typedef unsigned long HCURSOR;
	2527	typedef unsigned long HINSTANCE;
	2528	typedef unsigned long HIMAGELIST;
	2529	typedef unsigned long HGLOBAL;
	2530	typedef unsigned long DWORD;
	2531	typedef unsigned short WORD;
	2532	#endif /* WXPM \|\| EMX */
	2533
	2534	#if defined (__WXPM__)
	2535	/* WIN32 graphics types for OS/2 GPI */
	2536
	2537	/* RGB under OS2 is more like a PALETTEENTRY struct under Windows so we need a real RGB def */
	2538	/* WARNING: The OS/2 headers typedef BYTE simply as 'char'; if the default is signed, all */
	2539	/* hell will break loose! */
	2540	/* #define OS2RGB(r,g,b) ((DWORD ((BYTE) (b) \| ((WORD) (g) << 8)) \| (((DWORD)(BYTE)(r)) << 16))) */
	2541	#define OS2RGB(r,g,b) ((DWORD)((unsigned char)(b) \| ((unsigned char)(g) << 8)) \| ((unsigned char)(r) << 16))
	2542
	2543	typedef unsigned long COLORREF;
	2544	#define GetBValue(rgb) ((BYTE)((rgb) >> 16))
	2545	#define GetGValue(rgb) ((BYTE)(((WORD)(rgb)) >> 8))
	2546	#define GetRValue(rgb) ((BYTE)(rgb))
	2547	#define PALETTEINDEX(i) ((COLORREF)(0x01000000 \| (DWORD)(WORD)(i)))
	2548	#define PALETTERGB(r,g,b) (0x02000000 \| OS2RGB(r,g,b))
	2549	/* OS2's RGB/RGB2 is backwards from this */
	2550	typedef struct tagPALETTEENTRY
	2551	{
	2552	char bRed;
	2553	char bGreen;
	2554	char bBlue;
	2555	char bFlags;
	2556	} PALETTEENTRY;
	2557	typedef struct tagLOGPALETTE
	2558	{
	2559	WORD palVersion;
	2560	WORD palNumentries;
	2561	WORD PALETTEENTRY[1];
	2562	} LOGPALETTE;
	2563
	2564	#if (defined(__VISAGECPP__) && (__IBMCPP__ < 400)) \|\| defined (__WATCOMC__)
	2565	/* VA 3.0 for some reason needs base data types when typedefing a proc proto??? */
	2566	typedef void* (_System WXFARPROC)(unsigned long, unsigned long, void, void*);
	2567	#else
	2568	#if defined(__EMX__) && !defined(_System)
	2569	#define _System
	2570	#endif
	2571	typedef WXRESULT (_System *WXFARPROC)(WXHWND, WXMSGID, WXWPARAM, WXLPARAM);
	2572	#endif
	2573
	2574	#endif /* __WXPM__ */
	2575
	2576
	2577	#if defined(__WXMOTIF__) \|\| defined(__WXX11__)
	2578	/* Stand-ins for X/Xt/Motif types */
	2579	typedef void* WXWindow;
	2580	typedef void* WXWidget;
	2581	typedef void* WXAppContext;
	2582	typedef void* WXColormap;
	2583	typedef void* WXColor;
	2584	typedef void WXDisplay;
	2585	typedef void WXEvent;
	2586	typedef void* WXCursor;
	2587	typedef void* WXPixmap;
	2588	typedef void* WXFontStructPtr;
	2589	typedef void* WXGC;
	2590	typedef void* WXRegion;
	2591	typedef void* WXFont;
	2592	typedef void* WXImage;
	2593	typedef void* WXFontList;
	2594	typedef void* WXRendition;
	2595	typedef void* WXRenderTable;
	2596	typedef void* WXFontType; /* either a XmFontList or XmRenderTable */
	2597	typedef void* WXString;
	2598
	2599	typedef unsigned long Atom; /* this might fail on a few architectures */
	2600
	2601	#endif /* Motif */
	2602
	2603	#ifdef __WXGTK__
	2604
	2605	/* Stand-ins for GLIB types */
	2606	typedef char gchar;
	2607	typedef signed char gint8;
	2608	typedef int gint;
	2609	typedef unsigned guint;
	2610	typedef unsigned long gulong;
	2611	typedef void* gpointer;
	2612	typedef struct _GSList GSList;
	2613
	2614	/* Stand-ins for GDK types */
	2615	typedef struct _GdkColor GdkColor;
	2616	typedef struct _GdkColormap GdkColormap;
	2617	typedef struct _GdkFont GdkFont;
	2618	typedef struct _GdkGC GdkGC;
	2619	typedef struct _GdkVisual GdkVisual;
	2620
	2621	#ifdef __WXGTK20__
	2622	typedef struct _GdkAtom *GdkAtom;
	2623	typedef struct _GdkDrawable GdkWindow;
	2624	typedef struct _GdkDrawable GdkBitmap;
	2625	typedef struct _GdkDrawable GdkPixmap;
	2626	#else /* GTK+ 1.2 */
	2627	typedef gulong GdkAtom;
	2628	typedef struct _GdkWindow GdkWindow;
	2629	typedef struct _GdkWindow GdkBitmap;
	2630	typedef struct _GdkWindow GdkPixmap;
	2631	#endif /* GTK+ 1.2/2.0 */
	2632
	2633	typedef struct _GdkCursor GdkCursor;
	2634	typedef struct _GdkRegion GdkRegion;
	2635	typedef struct _GdkDragContext GdkDragContext;
	2636
	2637	#ifdef HAVE_XIM
	2638	typedef struct _GdkIC GdkIC;
	2639	typedef struct _GdkICAttr GdkICAttr;
	2640	#endif
	2641
	2642	/* Stand-ins for GTK types */
	2643	typedef struct _GtkWidget GtkWidget;
	2644	typedef struct _GtkRcStyle GtkRcStyle;
	2645	typedef struct _GtkAdjustment GtkAdjustment;
	2646	typedef struct _GtkList GtkList;
	2647	typedef struct _GtkToolbar GtkToolbar;
	2648	typedef struct _GtkTooltips GtkTooltips;
	2649	typedef struct _GtkNotebook GtkNotebook;
	2650	typedef struct _GtkNotebookPage GtkNotebookPage;
	2651	typedef struct _GtkAccelGroup GtkAccelGroup;
	2652	typedef struct _GtkItemFactory GtkItemFactory;
	2653	typedef struct _GtkSelectionData GtkSelectionData;
	2654	typedef struct _GtkTextBuffer GtkTextBuffer;
	2655
	2656	typedef GtkWidget *WXWidget;
	2657
	2658	#ifndef __WXGTK20__
	2659	#define GTK_OBJECT_GET_CLASS(object) (GTK_OBJECT(object)->klass)
	2660	#define GTK_CLASS_TYPE(klass) ((klass)->type)
	2661	#endif
	2662
	2663	#endif /* __WXGTK__ */
	2664
	2665	#if defined(__WXGTK20__) \|\| (defined(__WXX11__) && wxUSE_UNICODE)
	2666	#define wxUSE_PANGO 1
	2667	#else
	2668	#define wxUSE_PANGO 0
	2669	#endif
	2670
	2671	#if wxUSE_PANGO
	2672	/* Stand-ins for Pango types */
	2673	typedef struct _PangoContext PangoContext;
	2674	typedef struct _PangoLayout PangoLayout;
	2675	typedef struct _PangoFontDescription PangoFontDescription;
	2676	#endif
	2677
	2678	#ifdef __WXMGL__
	2679	typedef struct window_t *WXWidget;
	2680	#endif /* MGL */
	2681
	2682	/* This is required because of clashing macros in windows.h, which may be */
	2683	/* included before or after wxWidgets classes, and therefore must be */
	2684	/* disabled here before any significant wxWidgets headers are included. */
	2685	#ifdef __WXMSW__
	2686	#ifdef GetClassInfo
	2687	#undef GetClassInfo
	2688	#endif
	2689
	2690	#ifdef GetClassName
	2691	#undef GetClassName
	2692	#endif
	2693
	2694	#ifdef DrawText
	2695	#undef DrawText
	2696	#endif
	2697
	2698	#ifdef GetCharWidth
	2699	#undef GetCharWidth
	2700	#endif
	2701
	2702	#ifdef StartDoc
	2703	#undef StartDoc
	2704	#endif
	2705
	2706	#ifdef FindWindow
	2707	#undef FindWindow
	2708	#endif
	2709
	2710	#ifdef FindResource
	2711	#undef FindResource
	2712	#endif
	2713	#endif
	2714	/* __WXMSW__ */
	2715
	2716	/* --------------------------------------------------------------------------- */
	2717	/* macro to define a class without copy ctor nor assignment operator */
	2718	/* --------------------------------------------------------------------------- */
	2719
	2720	#define DECLARE_NO_COPY_CLASS(classname) \
	2721	private: \
	2722	classname(const classname&); \
	2723	classname& operator=(const classname&);
	2724
	2725	#define DECLARE_NO_ASSIGN_CLASS(classname) \
	2726	private: \
	2727	classname& operator=(const classname&);
	2728
	2729	#endif
	2730	/* _WX_DEFS_H_ */