removed almost all TeX code from main manual pages

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@51913 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2008-02-19 15:15:32 +00:00
parent 3d902bdfa8
commit 25c4a27cb3
14 changed files with 1730 additions and 327 deletions
--- a/docs/doxygen/categories.h
+++ b/docs/doxygen/categories.h
@@ -151,7 +151,7 @@
 @li wxStaticBox: A static, or group box for visually grouping related controls
 @li wxListBox: A list of strings for single or multiple selection
 @li wxListCtrl: A control for displaying lists of strings and/or icons, plus a multicolumn report view
- @li wxListView: A simpler interface (fa&?cedil;ade) for wxListCtrl in report mode
+ @li wxListView: A simpler interface (fa&ccedil;ade) for wxListCtrl in report mode
 @li wxOwnerDrawnComboBox: A combobox with owner-drawn list items
 @li wxRichTextCtrl: Generic rich text editing control
 @li wxTextCtrl: Single or multiline text editing control
@@ -494,8 +494,8 @@
 @li wxDocManager: Manages the documents and views in an application
 @li wxDocChildFrame: A child frame for showing a document view
 @li wxDocParentFrame: A parent frame to contain views
- %@li wxMDIDocChildFrame: An MDI child frame for showing a document view
+<!--  %@li wxMDIDocChildFrame: An MDI child frame for showing a document view
- %@li wxMDIDocParentFrame: An MDI parent frame to contain views
+ %@li wxMDIDocParentFrame: An MDI parent frame to contain views  -->
 @section cat_printing Printing framework
--- a/docs/doxygen/const_cpp.h
+++ b/docs/doxygen/const_cpp.h
@@ -0,0 +1,231 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        const_cpp.h
 // Purpose:     Preprocessor symbols
 // Author:      Vadim Zeitlin
 // RCS-ID:      $Id$
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 /*!
 @page cppconst Preprocessor symbols defined by wxWidgets
 These are preprocessor symbols used in the wxWidgets source, grouped
 by category (and sorted by alphabetical order inside each category).
 All of these macros except for the @c wxUSE_XXX variety is defined if the
 corresponding condition is @true and undefined if it isn't, so they should be
 always tested using @c #ifdef and not @c #if.
 TODO: what can we use here instead of \twocolitem to keep text readable??
 @li @ref guisystemconst
 @li @ref osconst
 @li @ref cpuconst
 @li @ref hardwareconst
 @li @ref compilerconst
 @li @ref featuretests
 @li @ref miscellaneousconst
 <hr>
 @section guisystemconst GUI system
 \twocolitem{__WINDOWS__}{any Windows, you may also use __WXMSW__}
 \twocolitem{__WIN16__}{Win16 API (not supported since wxWidgets 2.6)}
 \twocolitem{__WIN32__}{Win32 API}
 \twocolitem{__WXBASE__}{Only wxBase, no GUI features (same as @c wxUSE_GUI} $== 0$)}
 \twocolitem{__WXCOCOA__}{OS X using Cocoa API}
 \twocolitem{__WXDFB__}{wxUniversal using DirectFB}
 \twocolitem{__WXWINCE__}{Windows CE}
 \twocolitem{__WXGTK__}{GTK+}
 \twocolitem{__WXGTK12__}{GTK+ 1.2 or higher}
 \twocolitem{__WXGTK20__}{GTK+ 2.0 or higher}
 \twocolitem{__WXGTK24__}{GTK+ 2.4 or higher}
 \twocolitem{__WXGTK26__}{GTK+ 2.6 or higher}
 \twocolitem{__WXGTK210__}{GTK+ 2.10 or higher}
 \twocolitem{__WXMOTIF__}{Motif}
 \twocolitem{__WXMOTIF20__}{Motif 2.0 or higher}
 \twocolitem{__WXMAC__}{Mac OS all targets}
 \twocolitem{__WXMAC_CLASSIC__}{MacOS for Classic}
 \twocolitem{__WXMAC_CARBON__}{MacOS for Carbon CFM (running under Classic or OSX) or true OS X Mach-O Builds}
 \twocolitem{__WXMAC_OSX__}{MacOS X Carbon Mach-O Builds}
 \twocolitem{__WXMGL__}{SciTech Soft MGL (__WXUNIVERSAL__ will be also
 defined)}
 \twocolitem{__WXMSW__}{Any Windows}
 \twocolitem{__WXOSX__}{Any Mac OS X port (either Carbon or Cocoa)}
 \twocolitem{__WXPALMOS__}{PalmOS}
 \twocolitem{__WXPM__}{OS/2 native Presentation Manager}
 \twocolitem{__WXSTUBS__}{Stubbed version ('template' wxWin implementation)}
 \twocolitem{__WXXT__}{Xt; mutually exclusive with WX_MOTIF, not
 implemented in wxWidgets 2.x}
 \twocolitem{__WXX11__}{wxX11 (__WXUNIVERSAL__ will be also defined)}
 \twocolitem{__WXWINE__}{WINE (i.e. WIN32 on Unix)}
 \twocolitem{__WXUNIVERSAL__}{wxUniversal port, always defined in addition
 to one of the symbols above so this should be tested first.}
 \twocolitem{__X__}{any X11-based GUI toolkit except GTK+}
 There are two wxWidgets ports to Mac OS. One of them, wxMac, exists in two versions: 
 Classic and Carbon. The Classic version is the only one to work on Mac OS version 8. 
 The Carbon version may be built either as CFM or Mach-O (binary format, like ELF)
 and the former may run under OS 9 while the latter only runs under OS X.
 Finally, there is a new Cocoa port which can only be used under OS X. To
 summarize:
 @li If you want to test for all Mac platforms, classic and OS X, you
     should test both @c __WXMAC__ and @c __WXCOCOA__.
 @li If you want to test for any GUI Mac port under OS X, use
     @c __WXOSX__.
 @li If you want to test for any port under Mac OS X, including, for
     example, wxGTK and also wxBase, use @c __DARWIN__ (see below).
 The convention is to use the @c __WX prefix for these
 symbols, although this has not always been followed.
 @section osconst Operating systems
 \twocolitem{__APPLE__}{any Mac OS version}
 \twocolitem{__AIX__}{AIX}
 \twocolitem{__BSD__}{Any *BSD system}
 \twocolitem{__CYGWIN__}{Cygwin: Unix on Win32}
 \twocolitem{__DARWIN__}{Mac OS X using the BSD Unix C library (as opposed to using the Metrowerks MSL C/C++ library)}
 \twocolitem{__DATA_GENERAL__}{DG-UX}
 \twocolitem{__DOS_GENERAL__}{DOS (used with wxMGL only)}
 \twocolitem{__FREEBSD__}{FreeBSD}
 \twocolitem{__HPUX__}{HP-UX (Unix)}
 \twocolitem{__GNU__}{GNU Hurd}
 \twocolitem{__LINUX__}{Linux}
 \twocolitem{__MACH__}{Mach-O Architecture (Mac OS X only builds)}
 \twocolitem{__OSF__}{OSF/1}
 \twocolitem{__PALMOS__}{PalmOS}
 \twocolitem{__SGI__}{IRIX}
 \twocolitem{__SOLARIS__}{Solaris}
 \twocolitem{__SUN__}{Any Sun}
 \twocolitem{__SUNOS__}{Sun OS}
 \twocolitem{__SVR4__}{SystemV R4}
 \twocolitem{__SYSV__}{SystemV generic}
 \twocolitem{__ULTRIX__}{Ultrix}
 \twocolitem{__UNIX__}{any Unix}
 \twocolitem{__UNIX_LIKE__}{Unix, BeOS or VMS}
 \twocolitem{__VMS__}{VMS}
 \twocolitem{__WINDOWS__}{any Windows}
 \twocolitem{__WINE__}{Wine}
 @section cpuconst Hardware architectures (CPU)
 Note that not all of these symbols are always defined, it depends on the
 compiler used.
 \twocolitem{__ALPHA__}{DEC Alpha architecture}
 \twocolitem{__INTEL__}{Intel i386 or compatible}
 \twocolitem{__IA64__}{Intel 64 bit architecture}
 \twocolitem{__POWERPC__}{Motorola Power PC}
 @section hardwareconst Hardware type
 \twocolitem{__SMARTPHONE__}{Generic mobile devices with phone buttons and a small display}
 \twocolitem{__PDA__}{Personal digital assistant, usually with touch screen}
 \twocolitem{__HANDHELD__}{Small but powerful computer, usually with a keyboard}
 \twocolitem{__POCKETPC__}{Microsoft-powered PocketPC devices with touch-screen}
 \twocolitem{__WINCE_STANDARDSDK__}{Microsoft-powered Windows CE devices, for generic Windows CE applications}
 \twocolitem{__WINCE_NET__}{Microsoft-powered Windows CE .NET devices (_WIN32_WCE is 400 or greater)}
 \twocolitem{WIN32_PLATFORM_WFSP}{Microsoft-powered smartphone}
 @section compilerconst Compilers
 \twocolitem{__BORLANDC__}{Borland C++. The value of the macro corresponds
 to the compiler version: $500$ is $5.0$.}
 \twocolitem{__DJGPP__}{DJGPP}
 \twocolitem{__DIGITALMARS__}{Digital Mars}
 \twocolitem{__GNUG__}{Gnu C++ on any platform, see also
 \helpref{wxCHECK_GCC_VERSION}{wxcheckgccversion}}
 \twocolitem{__GNUWIN32__}{Gnu-Win32 compiler, see also
 \helpref{wxCHECK_W32API_VERSION}{wxcheckw32apiversion}}
 \twocolitem{__MINGW32__}{MinGW}
 \twocolitem{__MWERKS__}{CodeWarrior MetroWerks compiler}
 \twocolitem{__SUNCC__}{Sun CC, see also \helpref{wxCHECK_SUNCC_VERSION}{wxchecksunccversion}}
 \twocolitem{__SYMANTECC__}{Symantec C++}
 \twocolitem{__VISAGECPP__}{IBM Visual Age (OS/2)}
 \twocolitem{__VISUALC__}{Microsoft Visual C++, see also
 \helpref{wxCHECK_VISUALC_VERSION}{wxcheckvisualcversion}. The value of this
 macro corresponds to the compiler version: $1020$ for $4.2$ (the first supported
 version), $1100$ for $5.0$, $1200$ for $6.0$ and so on. For convenience, the
 symbols __VISUALCn__ are also defined for each major compiler version from
 5 to 9, i.e. you can use tests such @c #ifdef __VISUALC7__} to test
 for compiler version being precisely 7.}
 \twocolitem{__XLC__}{AIX compiler}
 \twocolitem{__WATCOMC__}{Watcom C++. The value of this macro corresponds to
 the compiler version, $1100$ is $11.0$ and $1200$ is OpenWatcom.}
 \twocolitem{_WIN32_WCE}{Windows CE version}
 @section featuretests Feature tests
 Some library features may not be always available even if they were selected by
 the user. To make it possible to check if this is the case, the library
 predefines the symbols in the form @c wxHAS_FEATURE. Unlike 
 @c wxUSE_FEATURE symbols which are defined by the library user (directly
 in @c setup.h or by running configure script) and which must be always
 defined as either $0$ or $1$, the @c wxHAS symbols are only defined if
 the corresponding feature is available and not defined at all otherwise.
 Currently the following symbols exist:
 \twocolitem{wxHAS_LARGE_FILES}{Defined if \helpref{wxFile}{wxfile} supports
 files more than 4GB in size.}
 \twocolitem{wxHAS_LARGE_FFILES}{Defined if \helpref{wxFFile}{wxffile}
 supports files more than 4GB in size.}
 \twocolitem{wxHAS_POWER_EVENTS}{Defined if 
 \helpref{wxPowerEvent}{wxpowerevent} are ever generated on the current platform.}
 \twocolitem{wxHAS_RADIO_MENU_ITEMS}{Defined if the current port supports 
 \helpref{radio menu items}{wxmenuappendradioitem}.}
 \twocolitem{wxHAS_RAW_KEY_CODES}{Defined if 
 \helpref{raw key codes}{wxkeyeventgetrawkeycode} are supported.}
 \twocolitem{wxHAS_REGEX_ADVANCED}{Defined if advanced syntax is available in 
 \helpref{wxRegEx}{wxregex}.}
 \twocolitem{wxHAS_TASK_BAR_ICON}{Defined if 
 \helpref{wxTaskBarIcon}{wxtaskbaricon} is available on the current platform.}
 @section miscellaneousconst Miscellaneous
 \twocolitem{__WXWINDOWS__}{always defined in wxWidgets applications, see
 also \helpref{wxCHECK_VERSION}{wxcheckversion}}
 \twocolitem{__WXDEBUG__}{defined in debug mode, undefined in release mode}
 \twocolitem{wxUSE_XXX}{if defined as $1$, feature XXX is active, see the 
 \helpref{complete list}{wxusedef} (the symbols of this form are always defined,
 use \#if and not \#ifdef to test for them)}
 \twocolitem{WX_PRECOMP}{is defined if precompiled headers (PCH) are in use. In
 this case, @c wx/wxprec.h} includes @c wx/wx.h} which, in turn,
 includes a number of wxWidgets headers thus making it unnecessary to include
 them explicitly. However if this is not defined, you do need to include them
 and so the usual idiom which allows to support both cases is to first include
 @c wx/wxprec.h} and then, inside @c #ifndef WX_PRECOMP}, individual
 headers you need.}
 \twocolitem{_UNICODE and UNICODE}{both are defined if wxUSE_UNICODE is set to $1$}
 \twocolitem{wxUSE_GUI}{this particular feature test macro is defined to $1$
 when compiling or using the library with the GUI features activated, if it is
 defined as $0$, only wxBase is available.}
 \twocolitem{wxUSE_BASE}{only used by wxWidgets internally (defined as $1$ when
 building wxBase code, either as a standalone library or as part of the
 monolithic wxWidgets library, defined as $0$ when building GUI library only)}
 \twocolitem{wxNO_RTTI}{is defined if the compiler RTTI support has been switched off}
 \twocolitem{wxNO_EXCEPTIONS}{is defined if the compiler support for C++
 exceptions has been switched off}
 \twocolitem{wxNO_THREADS}{if this macro is defined, the compilation options
 don't include compiler flags needed for multithreaded code generation. This
 implies that wxUSE_THREADS is $0$ and also that other (non-wx-based) threading
 packages cannot be used neither.}
 \twocolitem{WXMAKINGDLL_XXX}{used internally and defined when building the
 library @c XXX} as a DLL; when a monolithic wxWidgets build is used only a
 single @c WXMAKINGDLL} symbol is defined}
 \twocolitem{WXUSINGDLL}{defined when compiling code which uses wxWidgets as a
 DLL/shared library}
 \twocolitem{WXBUILDING}{defined when building wxWidgets itself, whether as a
 static or shared library}
 */
--- a/docs/doxygen/const_keycode.h
+++ b/docs/doxygen/const_keycode.h
@@ -0,0 +1,156 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        platdetails.h
 // Purpose:     wxKeyCode values enumerated
 // Author:      wxWidgets team
 // RCS-ID:      $Id$
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 /*!
 @page keycodes Keycodes
 Include file:
 @verbatim #include <wx/defs.h> @endverbatim
 Keypresses are represented by an enumerated type, wxKeyCode. The possible
 values are the ASCII character codes, plus the following:
 @verbatim
     WXK_BACK    = 8
     WXK_TAB     = 9
     WXK_RETURN  = 13
     WXK_ESCAPE  = 27
     WXK_SPACE   = 32
     WXK_DELETE  = 127
     // These are by design not compatible with unicode characters.
     // If you want to get a unicode character from a key event use
     // wxKeyEvent::GetUnicodeKey instead.
     WXK_START   = 300
     WXK_LBUTTON
     WXK_RBUTTON
     WXK_CANCEL
     WXK_MBUTTON
     WXK_CLEAR
     WXK_SHIFT
     WXK_ALT
     WXK_CONTROL
     WXK_MENU
     WXK_PAUSE
     WXK_CAPITAL
     WXK_END
     WXK_HOME
     WXK_LEFT
     WXK_UP
     WXK_RIGHT
     WXK_DOWN
     WXK_SELECT
     WXK_PRINT
     WXK_EXECUTE
     WXK_SNAPSHOT
     WXK_INSERT
     WXK_HELP
     WXK_NUMPAD0
     WXK_NUMPAD1
     WXK_NUMPAD2
     WXK_NUMPAD3
     WXK_NUMPAD4
     WXK_NUMPAD5
     WXK_NUMPAD6
     WXK_NUMPAD7
     WXK_NUMPAD8
     WXK_NUMPAD9
     WXK_MULTIPLY
     WXK_ADD
     WXK_SEPARATOR
     WXK_SUBTRACT
     WXK_DECIMAL
     WXK_DIVIDE
     WXK_F1
     WXK_F2
     WXK_F3
     WXK_F4
     WXK_F5
     WXK_F6
     WXK_F7
     WXK_F8
     WXK_F9
     WXK_F10
     WXK_F11
     WXK_F12
     WXK_F13
     WXK_F14
     WXK_F15
     WXK_F16
     WXK_F17
     WXK_F18
     WXK_F19
     WXK_F20
     WXK_F21
     WXK_F22
     WXK_F23
     WXK_F24
     WXK_NUMLOCK
     WXK_SCROLL
     WXK_PAGEUP,
     WXK_PAGEDOWN,
     WXK_NUMPAD_SPACE,
     WXK_NUMPAD_TAB,
     WXK_NUMPAD_ENTER,
     WXK_NUMPAD_F1,
     WXK_NUMPAD_F2,
     WXK_NUMPAD_F3,
     WXK_NUMPAD_F4,
     WXK_NUMPAD_HOME,
     WXK_NUMPAD_LEFT,
     WXK_NUMPAD_UP,
     WXK_NUMPAD_RIGHT,
     WXK_NUMPAD_DOWN,
     WXK_NUMPAD_PAGEUP,
     WXK_NUMPAD_PAGEDOWN,
     WXK_NUMPAD_END,
     WXK_NUMPAD_BEGIN,
     WXK_NUMPAD_INSERT,
     WXK_NUMPAD_DELETE,
     WXK_NUMPAD_EQUAL,
     WXK_NUMPAD_MULTIPLY,
     WXK_NUMPAD_ADD,
     WXK_NUMPAD_SEPARATOR,
     WXK_NUMPAD_SUBTRACT,
     WXK_NUMPAD_DECIMAL,
     WXK_NUMPAD_DIVIDE,
     // the following key codes are only generated under Windows currently
     WXK_WINDOWS_LEFT,
     WXK_WINDOWS_RIGHT,
     WXK_WINDOWS_MENU,
     WXK_COMMAND,
     // Hardware-specific buttons
     WXK_SPECIAL1 = 193,
     WXK_SPECIAL2,
     WXK_SPECIAL3,
     WXK_SPECIAL4,
     WXK_SPECIAL5,
     WXK_SPECIAL6,
     WXK_SPECIAL7,
     WXK_SPECIAL8,
     WXK_SPECIAL9,
     WXK_SPECIAL10,
     WXK_SPECIAL11,
     WXK_SPECIAL12,
     WXK_SPECIAL13,
     WXK_SPECIAL14,
     WXK_SPECIAL15,
     WXK_SPECIAL16,
     WXK_SPECIAL17,
     WXK_SPECIAL18,
     WXK_SPECIAL19,
     WXK_SPECIAL20
 @endverbatim
 */
--- a/docs/doxygen/const_keymod.h
+++ b/docs/doxygen/const_keymod.h
@@ -0,0 +1,42 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        keymod.h
 // Purpose:     key modifiers
 // Author:      wxWidgets team
 // RCS-ID:      $Id$
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 /*!
@page keymodifiers Key Modifiers
 Include file: @verbatim #include <wx/defs.h> @endverbatim
 The following key modifier constants are defined:
 @verbatim
     enum wxKeyModifier
     {
         wxMOD_NONE      = 0x0000,
         wxMOD_ALT       = 0x0001,
         wxMOD_CONTROL   = 0x0002,
         wxMOD_ALTGR     = wxMOD_ALT | wxMOD_CONTROL,
         wxMOD_SHIFT     = 0x0004,
         wxMOD_META      = 0x0008,
     #if defined(__WXMAC__) || defined(__WXCOCOA__)
         wxMOD_CMD       = wxMOD_META,
     #else
         wxMOD_CMD       = wxMOD_CONTROL,
     #endif
         wxMOD_ALL       = 0xffff
     };
 @endverbatim
 Notice that @c wxMOD\_CMD should be used instead of @c wxMOD_CONTROL 
 in portable code to account for the fact that although 
 @c Control modifier exists under Mac OS, it is not used for the same
 purpose as under Windows or Unix there while the special Mac-specific 
 @c Command modifier is used in exactly the same way.
 */
--- a/docs/doxygen/const_langcodes.h
+++ b/docs/doxygen/const_langcodes.h
@@ -0,0 +1,24 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        const_langcodes.h
 // Purpose:     Language values enumerated
 // Author:      wxWidgets team
 // RCS-ID:      $Id$
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 /*!
 @page languagecodes Language identifiers
 The following wxLanguage constants may be used to specify the language
 in wxLocale::Init and are returned by wxLocale::GetSystemLanguage:
 <!-- generated code begins here -->
  This enum is generated by misc/languages/genlang.py
  When making changes, please put them into misc/languages/langtabl.txt
 <!-- generated code ends here -->
 */
--- a/docs/doxygen/const_stdevtid.h
+++ b/docs/doxygen/const_stdevtid.h
@@ -0,0 +1,150 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        const_stdevtid.h
 // Purpose:     std event values enumerated
 // Author:      wxWidgets team
 // RCS-ID:      $Id$
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 /*!
 @page stdevtid Standard event identifiers
 wxWidgets defines a special identifier value @c wxID_ANY which is used in
 the following two situations:
 @li when creating a new window you may specify @c wxID_ANY to let
     wxWidgets assign an unused identifier to it automatically
 @li when installing an event handler using either the event table
     macros or wxEvtHandler::Connect,
     you may use it to indicate that you want to handle the events
     coming from any control, regardless of its identifier
 Another standard special identifier value is @c wxID_NONE: this is a value
 which is not matched by any other id.
 wxWidgets also defines a few standard command identifiers which may be used by
 the user code and also are sometimes used by wxWidgets itself. These reserved
 identifiers are all in the range between @c wxID_LOWEST and 
 @c wxID_HIGHEST and, accordingly, the user code should avoid defining its
 own constants in this range.
 @verbatim
     wxID_LOWEST = 4999,
     wxID_OPEN,
     wxID_CLOSE,
     wxID_NEW,
     wxID_SAVE,
     wxID_SAVEAS,
     wxID_REVERT,
     wxID_EXIT,
     wxID_UNDO,
     wxID_REDO,
     wxID_HELP,
     wxID_PRINT,
     wxID_PRINT_SETUP,
     wxID_PAGE_SETUP,
     wxID_PREVIEW,
     wxID_ABOUT,
     wxID_HELP_CONTENTS,
     wxID_HELP_INDEX,
     wxID_HELP_SEARCH,
     wxID_HELP_COMMANDS,
     wxID_HELP_PROCEDURES,
     wxID_HELP_CONTEXT,
     wxID_CLOSE_ALL,
     wxID_EDIT = 5030,
     wxID_CUT,
     wxID_COPY,
     wxID_PASTE,
     wxID_CLEAR,
     wxID_FIND,
     wxID_DUPLICATE,
     wxID_SELECTALL,
     wxID_DELETE,
     wxID_REPLACE,
     wxID_REPLACE_ALL,
     wxID_PROPERTIES,
     wxID_VIEW_DETAILS,
     wxID_VIEW_LARGEICONS,
     wxID_VIEW_SMALLICONS,
     wxID_VIEW_LIST,
     wxID_VIEW_SORTDATE,
     wxID_VIEW_SORTNAME,
     wxID_VIEW_SORTSIZE,
     wxID_VIEW_SORTTYPE,
     wxID_FILE = 5050,
     wxID_FILE1,
     wxID_FILE2,
     wxID_FILE3,
     wxID_FILE4,
     wxID_FILE5,
     wxID_FILE6,
     wxID_FILE7,
     wxID_FILE8,
     wxID_FILE9,
     // Standard button IDs
     wxID_OK = 5100,
     wxID_CANCEL,
     wxID_APPLY,
     wxID_YES,
     wxID_NO,
     wxID_STATIC,
     wxID_FORWARD,
     wxID_BACKWARD,
     wxID_DEFAULT,
     wxID_MORE,
     wxID_SETUP,
     wxID_RESET,
     wxID_CONTEXT_HELP,
     wxID_YESTOALL,
     wxID_NOTOALL,
     wxID_ABORT,
     wxID_RETRY,
     wxID_IGNORE,
     wxID_UP,
     wxID_DOWN,
     wxID_HOME,
     wxID_REFRESH,
     wxID_STOP,
     wxID_INDEX,
     wxID_BOLD,
     wxID_ITALIC,
     wxID_JUSTIFY_CENTER,
     wxID_JUSTIFY_FILL,
     wxID_JUSTIFY_RIGHT,
     wxID_JUSTIFY_LEFT,
     wxID_UNDERLINE,
     wxID_INDENT,
     wxID_UNINDENT,
     wxID_ZOOM_100,
     wxID_ZOOM_FIT,
     wxID_ZOOM_IN,
     wxID_ZOOM_OUT,
     wxID_UNDELETE,
     wxID_REVERT_TO_SAVED,
     // System menu IDs (used by wxUniv):
     wxID_SYSTEM_MENU = 5200,
     wxID_CLOSE_FRAME,
     wxID_MOVE_FRAME,
     wxID_RESIZE_FRAME,
     wxID_MAXIMIZE_FRAME,
     wxID_ICONIZE_FRAME,
     wxID_RESTORE_FRAME,
     // IDs used by generic file dialog (13 consecutive starting from this value)
     wxID_FILEDLGG = 5900,
     wxID_HIGHEST = 5999
 @endverbatim
 */
--- a/docs/doxygen/const_stockitems.h
+++ b/docs/doxygen/const_stockitems.h
@@ -0,0 +1,78 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        const_stockitems.h
 // Purpose:     stock item values enumerated
 // Author:      wxWidgets team
 // RCS-ID:      $Id$
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 /*!
 @page stockitems Stock items
 Window IDs for which stock buttons and menu items are created
 (see the wxButton constructor and the wxMenuItem constructor):
 TODO: what can we use here instead of \twocolitem to keep text readable??
 \twocolitem{{\bf Stock ID}}{{\bf Stock label}}
 \twocolitem{wxID_ABOUT}{"&About"}
 \twocolitem{wxID_ADD}{"Add"}
 \twocolitem{wxID_APPLY}{"&Apply"}
 \twocolitem{wxID_BOLD}{"&Bold"}
 \twocolitem{wxID_CANCEL}{"&Cancel"}
 \twocolitem{wxID_CLEAR}{"&Clear"}
 \twocolitem{wxID_CLOSE}{"&Close"}
 \twocolitem{wxID_COPY}{"&Copy"}
 \twocolitem{wxID_CUT}{"Cu&t"}
 \twocolitem{wxID_DELETE}{"&Delete"}
 \twocolitem{wxID_EDIT}{"&Edit"}
 \twocolitem{wxID_FIND}{"&Find"}
 \twocolitem{wxID_FILE}{"&File"}
 \twocolitem{wxID_REPLACE}{"Find and rep&lace"}
 \twocolitem{wxID_BACKWARD}{"&Back"}
 \twocolitem{wxID_DOWN}{"&Down"}
 \twocolitem{wxID_FORWARD}{"&Forward"}
 \twocolitem{wxID_UP}{"&Up"}
 \twocolitem{wxID_HELP}{"&Help"}
 \twocolitem{wxID_HOME}{"&Home"}
 \twocolitem{wxID_INDENT}{"Indent"}
 \twocolitem{wxID_INDEX}{"&Index"}
 \twocolitem{wxID_ITALIC}{"&Italic"}
 \twocolitem{wxID_JUSTIFY_CENTER}{"Centered"}
 \twocolitem{wxID_JUSTIFY_FILL}{"Justified"}
 \twocolitem{wxID_JUSTIFY_LEFT}{"Align Left"}
 \twocolitem{wxID_JUSTIFY_RIGHT}{"Align Right"}
 \twocolitem{wxID_NEW}{"&New"}
 \twocolitem{wxID_NO}{"&No"}
 \twocolitem{wxID_OK}{"&OK"}
 \twocolitem{wxID_OPEN}{"&Open"}
 \twocolitem{wxID_PASTE}{"&Paste"}
 \twocolitem{wxID_PREFERENCES}{"&Preferences"}
 \twocolitem{wxID_PRINT}{"&Print"}
 \twocolitem{wxID_PREVIEW}{"Print previe&w"}
 \twocolitem{wxID_PROPERTIES}{"&Properties"}
 \twocolitem{wxID_EXIT}{"&Quit"}
 \twocolitem{wxID_REDO}{"&Redo"}
 \twocolitem{wxID_REFRESH}{"Refresh"}
 \twocolitem{wxID_REMOVE}{"Remove"}
 \twocolitem{wxID_REVERT_TO_SAVED}{"Revert to Saved"}
 \twocolitem{wxID_SAVE}{"&Save"}
 \twocolitem{wxID_SAVEAS}{"Save &As..."}
 \twocolitem{wxID_SELECTALL}{"Select all"}
 \twocolitem{wxID_STOP}{"&Stop"}
 \twocolitem{wxID_UNDELETE}{"Undelete"}
 \twocolitem{wxID_UNDERLINE}{"&Underline"}
 \twocolitem{wxID_UNDO}{"&Undo"}
 \twocolitem{wxID_UNINDENT}{"&Unindent"}
 \twocolitem{wxID_YES}{"&Yes"}
 \twocolitem{wxID_ZOOM_100}{"&Actual Size"}
 \twocolitem{wxID_ZOOM_FIT}{"Zoom to &Fit"}
 \twocolitem{wxID_ZOOM_IN}{"Zoom &In"}
 \twocolitem{wxID_ZOOM_OUT}{"Zoom &Out"}
 Note that some of the IDs listed above have also a stock accelerator
 and an help string associated.
 */
--- a/docs/doxygen/const_wxusedef.h
+++ b/docs/doxygen/const_wxusedef.h
@@ -0,0 +1,342 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        const_wxusedef.h
 // Purpose:     wxUSE preprocessor symbols
 // Author:      Tim Stahlhut
 // RCS-ID:      $Id$
 // Licence:     wxWindows license
 /////////////////////////////////////////////////////////////////////////////
 /*!
 @page wxusedef wxUSE Preprocessor symbols defined by wxWidgets
 This section documents the wxUSE preprocessor symbols used in the wxWidgets
 source, grouped by category (and sorted by alphabetical order inside each
 category). These symbols are always defined and whether the given feature is
 active or not depends on their value: if defined as @c 1, feature is active,
 otherwise it is disabled. Because of this these symbols should be always tested
 using @c #if and not @c #ifdef.
 @li @ref wxusedefmulti
 @li @ref wxusedefunix
 @li @ref wxusedefx11
 @li @ref wxusedefgtk
 @li @ref wxusedefmac
 @li @ref wxusedefmotif
 @li @ref wxusedefcocoa
 @li @ref wxusedefos2
 @li @ref wxusedefmsw
 @li @ref wxusedefuniv
 <hr>
 TODO: what can we use here instead of \twocolitem to keep text readable??
 @section wxusedefmulti Generic wxUSE preprocessor symbols
 \twocolitem{wxUSE_ABOUTDLG}{Use \helpref{wxAboutDialogInfo}{wxaboutdialoginfo} class.}
 \twocolitem{wxUSE_ACCEL}{Use \helpref{wxAcceleratorTable}{wxacceleratortable}/Entry classes and support for them in \helpref{wxMenu}{wxmenu}(Bar).}
 \twocolitem{wxUSE_AFM_FOR_POSTSCRIPT}{In \helpref{wxPostScriptDC}{wxpostscriptdc} class use AFM (adobe font metrics) file for character widths.}
 \twocolitem{wxUSE_ANIMATIONCTRL}{Use \helpref{wxAnimationCtrl}{wxanimationctrl} class.}
 \twocolitem{wxUSE_APPLE_IEEE}{IEEE Extended to/from double routines; see src/common/extended.c file.}
 \twocolitem{wxUSE_ARCHIVE_STREAMS}{Enable streams for archive formats.}
 \twocolitem{wxUSE_AUI}{Use AUI (dockable windows) library.}
 \twocolitem{wxUSE_BASE64}{Enables Base64 support.}
 \twocolitem{wxUSE_BITMAPCOMBOBOX}{Use \helpref{wxBitmapComboBox}{wxbitmapcombobox} class.}
 \twocolitem{wxUSE_BMPBUTTON}{Use \helpref{wxBitmapButton}{wxbitmapbutton} class.}
 \twocolitem{wxUSE_BUSYINFO}{Use \helpref{wxBusyInfo}{wxbusyinfo} class.}
 \twocolitem{wxUSE_BUTTON}{Use \helpref{wxButton}{wxbutton} class.}
 \twocolitem{wxUSE_CALENDARCTRL}{Use \helpref{wxCalendarCtrl}{wxcalendarctrl} class.}
 \twocolitem{wxUSE_CARET}{Use \helpref{wxCaret}{wxcaret} class.}
 \twocolitem{wxUSE_CHECKBOX}{Use \helpref{wxCheckBox}{wxcheckbox} class.}
 \twocolitem{wxUSE_CHECKLISTBOX}{Use \helpref{wxCheckListBox}{wxchecklistbox} class.}
 \twocolitem{wxUSE_CHOICE}{Use \helpref{wxChoice}{wxchoice} class.}
 \twocolitem{wxUSE_CHOICEBOOK}{Use \helpref{wxChoicebook}{wxchoicebook} class.}
 \twocolitem{wxUSE_CHOICEDLG}{Use \helpref{wxSingleChoiceDialog}{wxsinglechoicedialog} or \helpref{wxMultiChoiceDialog}{wxmultichoicedialog} classes.}
 \twocolitem{wxUSE_CLIPBOARD}{Use \helpref{wxClipboard}{wxclipboard} class.}
 \twocolitem{wxUSE_CMDLINE_PARSER}{Use \helpref{wxCmdLineParser}{wxcmdlineparser} class.}
 \twocolitem{wxUSE_COLLPANE}{Use \helpref{wxCollapsiblePane}{wxcollapsiblepane} class.}
 \twocolitem{wxUSE_COLOURDLG}{Use \helpref{wxColourDialog}{wxcolourdialog} class.}
 \twocolitem{wxUSE_COLOURPICKERCTRL}{Use \helpref{wxColourPickerCtrl}{wxcolourpickerctrl} class.}
 \twocolitem{wxUSE_COMBOBOX}{Use \helpref{wxComboBox}{wxcombobox} class.}
 \twocolitem{wxUSE_COMBOCTRL}{Use \helpref{wxComboCtrl}{wxcomboctrl} class.}
 \twocolitem{wxUSE_CONFIG}{Use \helpref{wxConfig}{wxconfigbase} and related classes.}
 \twocolitem{wxUSE_CONFIG_NATIVE}{When enabled use native OS configuration instead of the \helpref{wxFileConfig}{wxfileconfig} class.}
 \twocolitem{wxUSE_CONSOLE_EVENTLOOP}{Enable event loop in console programs.}
 \twocolitem{wxUSE_CONSTRAINTS}{Use \helpref{wxLayoutConstraints}{wxlayoutconstraints}}
 \twocolitem{wxUSE_CONTROLS}{If set to $0$, no classes deriving from \helpref{wxControl}{wxcontrol} can be used.}
 \twocolitem{wxUSE_DATAOBJ}{Use \helpref{wxDataObject}{wxdataobject} and related classes.}
 \twocolitem{wxUSE_DATAVIEWCTRL}{Use \helpref{wxDataViewCtrl}{wxdataviewctrl} class.}
 \twocolitem{wxUSE_DATEPICKCTRL}{Use \helpref{wxDatePickerCtrl}{wxdatepickerctrl} class.}
 \twocolitem{wxUSE_DATETIME}{Use \helpref{wxDateTime}{wxdatetime} and related classes.}
 \twocolitem{wxUSE_DBGHELP}{Use wxDbgHelpDLL class.}
 \twocolitem{wxUSE_DEBUG_CONTEXT}{Use \helpref{wxDebugContext}{wxdebugcontext} class.}
 \twocolitem{wxUSE_DEBUG_NEW_ALWAYS}{See \helpref{Debugging overview}{wxdebugcontextoverview}}
 \twocolitem{wxUSE_DEBUGREPORT}{Use \helpref{wxDebugReport}{wxdebugreport} class.}
 \twocolitem{wxUSE_DIALUP_MANAGER}{Use \helpref{wxDialUpManager}{wxdialupmanager} and related classes.}
 \twocolitem{wxUSE_DIRDLG}{Use \helpref{wxDirDialog}{wxdirdialog} class.}
 \twocolitem{wxUSE_DIRPICKERCTRL}{Use \helpref{wxDirPickerCtrl}{wxdirpickerctrl} class.}
 \twocolitem{wxUSE_DISPLAY}{Use \helpref{wxDisplay}{wxdisplay} and related classes.}
 \twocolitem{wxUSE_DOC_VIEW_ARCHITECTURE}{Use \helpref{wxDocument}{wxdocument} and related classes.}
 \twocolitem{wxUSE_DRAG_AND_DROP}{Use \helpref{Drag and drop}{wxdndoverview} classes.}
 \twocolitem{wxUSE_DRAGIMAGE}{Use \helpref{wxDragImage}{wxdragimage} class.}
 \twocolitem{wxUSE_DYNAMIC_LOADER}{Use wxPluginManager and related classes. Requires \helpref{wxDynamicLibrary}{wxdynamiclibrary}}
 \twocolitem{wxUSE_DYNLIB_CLASS}{Use \helpref{wxDynamicLibrary}{wxdynamiclibrary}}
 \twocolitem{wxUSE_EDITABLELISTBOX}{Use \helpref{wxEditableListBox}{wxeditablelistbox} class.}
 \twocolitem{wxUSE_EXCEPTIONS}{Use \helpref{exception handling}{exceptionsoverview}.}
 \twocolitem{wxUSE_EXPAT}{enable XML support using expat parser.}
 \twocolitem{wxUSE_EXTENDED_RTTI}{Use extended RTTI, see also \helpref{Runtime class information (RTTI)}{runtimeclassoverview}}
 \twocolitem{wxUSE_FFILE}{Use \helpref{wxFFile}{wxffile} class.}
 \twocolitem{wxUSE_FILE}{Use \helpref{wxFile}{wxfile} class.}
 \twocolitem{wxUSE_FILECONFIG}{Use \helpref{wxFileConfig}{wxfileconfig} class.}
 \twocolitem{wxUSE_FILECTRL}{Use \helpref{wxFileCtrl}{wxfilectrl} class.}
 \twocolitem{wxUSE_FILEDLG}{Use \helpref{wxFileDialog}{wxfiledialog} class.}
 \twocolitem{wxUSE_FILEPICKERCTRL}{Use \helpref{wxFilePickerCtrl}{wxfilepickerctrl} class.}
 \twocolitem{wxUSE_FILESYSTEM}{Use \helpref{wxFileSystem}{wxfilesystem} and related classes.}
 \twocolitem{wxUSE_FINDREPLDLG}{Use \helpref{wxFindReplaceDialog}{wxfindreplacedialog} class.}
 \twocolitem{wxUSE_FONTDLG}{Use \helpref{wxFontDialog}{wxfontdialog} class.}
 \twocolitem{wxUSE_FONTENUM}{Use \helpref{wxFontEnumerator}{wxfontenumerator} class.}
 \twocolitem{wxUSE_FONTMAP}{Use \helpref{wxFontMapper}{wxfontmapper} class.}
 \twocolitem{wxUSE_FONTPICKERCTRL}{Use \helpref{wxFontPickerCtrl}{wxfontpickerctrl} class.}
 \twocolitem{wxUSE_FS_ARCHIVE}{Use virtual archive filesystems like wxArchiveFSHandler in \helpref{wxFileSystem}{wxfilesystem} class.}
 \twocolitem{wxUSE_FS_INET}{Use virtual HTTP/FTP filesystems like wxInternetFSHandler in \helpref{wxFileSystem}{wxfilesystem} class.}
 \twocolitem{wxUSE_FS_ZIP}{Please use wxUSE_FS_ARCHIVE instead.}
 \twocolitem{wxUSE_FSVOLUME}{Use wxFSVolume class.}
 \twocolitem{wxUSE_GAUGE}{Use \helpref{wxGauge}{wxgauge} class.}
 \twocolitem{wxUSE_GENERIC_DRAGIMAGE}{Used in wxDragImage sample.}
 \twocolitem{wxUSE_GENERIC_DRAWELLIPSE}{See comment in wx/dc.h file.}
 \twocolitem{wxUSE_GEOMETRY}{Use common geometry classes}
 \twocolitem{wxUSE_GIF}{Use GIF \helpref{wxImageHandler}{wximagehandler}}
 \twocolitem{wxUSE_GLCANVAS}{Enables OpenGL support.}
 \twocolitem{wxUSE_GLOBAL_MEMORY_OPERATORS}{Override global operators \texttt{new} and \texttt{delete} to use wxWidgets memory leak detection}
 \twocolitem{wxUSE_GRAPHICS_CONTEXT}{Use \helpref{wxGraphicsContext}{wxgraphicscontext} and related classes.}
 \twocolitem{wxUSE_GRID}{Use \helpref{wxGrid}{wxgrid} and related classes.}
 \twocolitem{wxUSE_GUI}{Use the GUI classes; if set to $0$ only non-GUI classes are available.}
 \twocolitem{wxUSE_HELP}{Use \helpref{wxHelpController}{wxhelpcontroller} and related classes.}
 \twocolitem{wxUSE_HTML}{Use \helpref{wxHtmlWindow}{wxhtmlwindow} and related classes.}
 \twocolitem{wxUSE_HYPERLINKCTRL}{Use \helpref{wxHyperlinkCtrl}{wxhyperlinkctrl}}
 \twocolitem{wxUSE_ICO_CUR}{Support Windows ICO and CUR formats.}
 \twocolitem{wxUSE_IFF}{Enables the \helpref{wxImage}{wximage} handler for Amiga IFF images.}
 \twocolitem{wxUSE_IMAGE}{Use \helpref{wxImage}{wximage} and related classes.}
 \twocolitem{wxUSE_IMAGLIST}{Use \helpref{wxImageList}{wximagelist} class.}
 \twocolitem{wxUSE_INTL}{Use \helpref{wxLocale}{wxlocale} and related classes.}
 \twocolitem{wxUSE_IOSTREAMH}{Use header <iostream.h> instead of <iostream>.}
 \twocolitem{wxUSE_IPC}{Use interprocess communication classes.}
 \twocolitem{wxUSE_IPV6}{Use experimental \helpref{wxIPV6address}{wxipaddress} and related classes.}
 \twocolitem{wxUSE_JOYSTICK}{Use \helpref{wxJoystick}{wxjoystick} class.}
 \twocolitem{wxUSE_LIBJPEG}{Enables JPEG format support (requires libjpeg).}
 \twocolitem{wxUSE_LIBPNG}{Enables PNG format support (requires libpng). Also requires wxUSE_ZLIB.}
 \twocolitem{wxUSE_LIBTIFF}{Enables TIFF format support (requires libtiff).}
 \twocolitem{wxUSE_LISTBOOK}{Use \helpref{wxListbook}{wxlistbook} class.}
 \twocolitem{wxUSE_LISTBOX}{Use \helpref{wxListBox}{wxlistbox} class.}
 \twocolitem{wxUSE_LISTCTRL}{Use \helpref{wxListCtrl}{wxlistctrl} class.}
 \twocolitem{wxUSE_LOG}{Use \helpref{wxLog}{wxlog} and related classes.}
 \twocolitem{wxUSE_LOG_DEBUG}{Enabled when wxLog used with __WXDEBUG__ defined.}
 \twocolitem{wxUSE_LOG_DIALOG}{Use wxLogDialog class.}
 \twocolitem{wxUSE_LOGGUI}{Use \helpref{wxLogGui}{wxloggui} class.}
 \twocolitem{wxUSE_LOGWINDOW}{Use wxLogFrame class.}
 \twocolitem{wxUSE_LONGLONG}{Use \helpref{wxLongLong}{wxlonglong} class.}
 \twocolitem{wxUSE_LONGLONG_NATIVE}{Use native \texttt{long long} type in \helpref{wxLongLong}{wxlonglong} implementation.}
 \twocolitem{wxUSE_LONGLONG_WX}{Use generic wxLongLong implementation.}
 \twocolitem{wxUSE_MDI}{Use \helpref{wxMDIParentFrame}{wxmdiparentframe} and \helpref{wxMDIChildFrame}{wxmdichildframe}}
 \twocolitem{wxUSE_MDI_ARCHITECTURE}{Use MDI-based document-view classes.}
 \twocolitem{wxUSE_MEDIACTRL}{Use \helpref{wxMediaCtrl}{wxmediactrl}.}
 \twocolitem{wxUSE_MEMORY_TRACING}{Use wxWidgets memory leak detection, not recommended if using another memory debugging tool.}
 \twocolitem{wxUSE_MENUS}{Use \helpref{wxMenu}{wxmenu} and related classes.}
 \twocolitem{wxUSE_METAFILE}{Use \helpref{wxMetaFile}{wxmetafile} and related classes.}
 \twocolitem{wxUSE_MIMETYPE}{Use \helpref{wxFileType}{wxfiletype} class.}
 \twocolitem{wxUSE_MINIFRAME}{Use \helpref{wxMiniFrame}{wxminiframe} class.}
 \twocolitem{wxUSE_MOUSEWHEEL}{Support mouse wheel events.}
 \twocolitem{wxUSE_MSGDLG}{Use \helpref{wxMessageDialog}{wxmessagedialog} class and \helpref{wxMessageBox}{wxmessagebox} function.}
 \twocolitem{wxUSE_NATIVE_STATUSBAR}{Use native \helpref{wxStatusBar}{wxstatusbar} class.}
 \twocolitem{wxUSE_NOTEBOOK}{Use \helpref{wxNotebook}{wxnotebook} and related classes.}
 \twocolitem{wxUSE_NUMBERDLG}{Use wxNumberEntryDialog class.}
 \twocolitem{wxUSE_ODCOMBOBOX}{Use \helpref{wxOwnerDrawnComboBox}{wxownerdrawncombobox} class.}
 \twocolitem{wxUSE_ON_FATAL_EXCEPTION}{Catch signals in \helpref{wxApp::OnFatalException}{wxapponfatalexception} method.}
 \twocolitem{wxUSE_OPENGL}{Please use wxUSE_GLCANVAS to test for enabled OpenGL support instead.}
 \twocolitem{wxUSE_OWNER_DRAWN}{Use interface for owner-drawn GUI elements.}
 \twocolitem{wxUSE_PALETTE}{Use \helpref{wxPalette}{wxpalette} and related classes.}
 \twocolitem{wxUSE_PCX}{Enables \helpref{wxImage}{wximage} PCX handler.}
 \twocolitem{wxUSE_PNM}{Enables \helpref{wxImage}{wximage} PNM handler.}
 \twocolitem{wxUSE_POPUPWIN}{Use wxPopupWindow class.}
 \twocolitem{wxUSE_POSTSCRIPT}{Use wxPostScriptPrinter class.}
 \twocolitem{wxUSE_PRINTF_POS_PARAMS}{Use \helpref{wxVsnprintf}{wxvsnprintf} which supports positional parameters.}
 \twocolitem{wxUSE_PRINTING_ARCHITECTURE}{Enable printer classes.}
 \twocolitem{wxUSE_PROGRESSDLG}{Enables progress dialog classes.}
 \twocolitem{wxUSE_PROTOCOL}{Use \helpref{wxProtocol}{wxprotocol} and derived classes.}
 \twocolitem{wxUSE_PROTOCOL_FILE}{Use wxFileProto class. (requires \helpref{wxProtocol}{wxprotocol})}
 \twocolitem{wxUSE_PROTOCOL_FTP}{Use \helpref{wxFTP}{wxftp} class. (requires \helpref{wxProtocol}{wxprotocol})}
 \twocolitem{wxUSE_PROTOCOL_HTTP}{Use \helpref{wxHTTP}{wxhttp} class. (requires \helpref{wxProtocol}{wxprotocol})}
 \twocolitem{wxUSE_RADIOBOX}{Use \helpref{wxRadioBox}{wxradiobox} class.}
 \twocolitem{wxUSE_RADIOBTN}{Use \helpref{wxRadioButton}{wxradiobutton} class.}
 \twocolitem{wxUSE_REGEX}{Use \helpref{wxRegEx}{wxregex} class.}
 \twocolitem{wxUSE_RICHTEXT}{Use \helpref{wxRichTextCtrl}{wxrichtextctrl} class.}
 \twocolitem{wxUSE_RICHTEXT_XML_HANDLER}{See src/xrc/xh_richtext.cpp file.}
 \twocolitem{wxUSE_SASH}{Use \helpref{wxSashWindow}{wxsashwindow} class.}
 \twocolitem{wxUSE_SCROLLBAR}{Use \helpref{wxScrollBar}{wxscrollbar} class.}
 \twocolitem{wxUSE_SEARCHCTRL}{Use \helpref{wxSearchCtrl}{wxsearchctrl} class.}
 \twocolitem{wxUSE_SELECT_DISPATCHER}{Use wxSelectDispatcher class.}
 \twocolitem{wxUSE_SLIDER}{Use \helpref{wxSlider}{wxslider} class.}
 \twocolitem{wxUSE_SNGLINST_CHECKER}{Use \helpref{wxSingleInstanceChecker}{wxsingleinstancechecker} class.}
 \twocolitem{wxUSE_SOCKETS}{Enables Network address classes.}
 \twocolitem{wxUSE_SOUND}{Use \helpref{wxSound}{wxsound} class.}
 \twocolitem{wxUSE_SPINBTN}{Use \helpref{wxSpinButton}{wxspinbutton} class.}
 \twocolitem{wxUSE_SPINCTRL}{Use \helpref{wxSpinCtrl}{wxspinctrl} class.}
 \twocolitem{wxUSE_SPLASH}{Use \helpref{wxSplashScreen}{wxsplashscreen} class.}
 \twocolitem{wxUSE_SPLINES}{Provide methods for spline drawing in wxDC.}
 \twocolitem{wxUSE_SPLITTER}{Use \helpref{wxSplitterWindow}{wxsplitterwindow} class.}
 \twocolitem{wxUSE_STACKWALKER}{Enables \helpref{wxStackWalker}{wxstackwalker} and related classes.}
 \twocolitem{wxUSE_STARTUP_TIPS}{Use startup tips, \helpref{wxTipProvider}{wxtipprovider} class.}
 \twocolitem{wxUSE_STATBMP}{Use \helpref{wxStaticBitmap}{wxstaticbitmap} class.}
 \twocolitem{wxUSE_STATBOX}{Use \helpref{wxStaticBox}{wxstaticbox} class.}
 \twocolitem{wxUSE_STATLINE}{Use \helpref{wxStaticLine}{wxstaticline} class.}
 \twocolitem{wxUSE_STATTEXT}{Use \helpref{wxStaticText}{wxstatictext} class.}
 \twocolitem{wxUSE_STATUSBAR}{Use \helpref{wxStatusBar}{wxstatusbar} class.}
 \twocolitem{wxUSE_STC}{Use wxStyledTextCtrl.}
 \twocolitem{wxUSE_STD_IOSTREAM}{Use standard C++ stream classes.}
 \twocolitem{wxUSE_STD_STRING}{Use standard C++ string classes.}
 \twocolitem{wxUSE_STDPATHS}{Use \helpref{wxStandardPaths}{wxstandardpaths} class.}
 \twocolitem{wxUSE_STL}{Use Standard Template Library for the container classes and \helpref{wxString}{wxstring} implementation.}
 \twocolitem{wxUSE_STOPWATCH}{Use \helpref{wxStopWatch}{wxstopwatch} class.}
 \twocolitem{wxUSE_STREAMS}{Enable stream classes.}
 \twocolitem{wxUSE_SVG}{Use wxSVGFileDC class.}
 \twocolitem{wxUSE_SYSTEM_OPTIONS}{Use \helpref{wxSystemOptions}{wxsystemoptions} class.}
 \twocolitem{wxUSE_TAB_DIALOG}{Use the obsolete wxTabControl class.}
 \twocolitem{wxUSE_TARSTREAM}{Enable Tar files support.}
 \twocolitem{wxUSE_TASKBARICON}{Use \helpref{wxTaskBarIcon}{wxtaskbaricon} class.}
 \twocolitem{wxUSE_TEXTBUFFER}{Use wxTextBuffer class.}
 \twocolitem{wxUSE_TEXTCTRL}{Use \helpref{wxTextCtrl}{wxtextctrl} class.}
 \twocolitem{wxUSE_TEXTDLG}{Use \helpref{wxTextEntryDialog}{wxtextentrydialog} class.}
 \twocolitem{wxUSE_TEXTFILE}{Use \helpref{wxTextFile}{wxtextfile} class.}
 \twocolitem{wxUSE_TGA}{Enable \helpref{wxImage}{wximage} TGA handler.}
 \twocolitem{wxUSE_THREADS}{Use \helpref{wxThread}{wxthread} and related classes.}
 \twocolitem{wxUSE_TIMER}{Use \helpref{wxTimer}{wxtimer} class.}
 \twocolitem{wxUSE_TIPWINDOW}{Use \helpref{wxTipWindow}{wxtipwindow} class.}
 \twocolitem{wxUSE_TOGGLEBTN}{Use \helpref{wxToggleButton}{wxtogglebutton} class.}
 \twocolitem{wxUSE_TOOLBAR}{Use \helpref{wxToolBar}{wxtoolbar} class.}
 \twocolitem{wxUSE_TOOLBAR_NATIVE}{Use native \helpref{wxToolBar}{wxtoolbar} class.}
 \twocolitem{wxUSE_TOOLBOOK}{Use \helpref{wxToolbook}{wxtoolbook} class.}
 \twocolitem{wxUSE_TOOLTIPS}{Use \helpref{wxToolTip}{wxtooltip} class.}
 \twocolitem{wxUSE_TREEBOOK}{Use \helpref{wxTreebook}{wxtreebook} class.}
 \twocolitem{wxUSE_TREECTRL}{Use \helpref{wxTreeCtrl}{wxtreectrl} class.}
 \twocolitem{wxUSE_TTM_WINDOWFROMPOINT}{Obsolete, do not use.}
 \twocolitem{wxUSE_UNICODE}{Compiled with Unicode support.}
 \twocolitem{wxUSE_UNICODE_UTF8}{Compiled with UTF8 support.}
 \twocolitem{wxUSE_UNICODE_WCHAR}{Compiled with Unicode support and using wchar_t type.}
 \twocolitem{wxUSE_URL}{Use \helpref{wxURL}{wxurl} class.}
 \twocolitem{wxUSE_URL_NATIVE}{Use native support for some operations with \helpref{wxURL}{wxurl}.}
 \twocolitem{wxUSE_UTF8_LOCALE_ONLY}{Build wxWidgets to support running only under UTF-8 (and C) locale. This eliminates the code necessary for conversions from the other locales and reduces the library size; useful for embedded systems.}
 \twocolitem{wxUSE_VALIDATORS}{Use \helpref{wxValidator}{wxvalidator} class.}
 \twocolitem{wxUSE_VARIANT}{Use \helpref{wxVariant}{wxvariant} class.}
 \twocolitem{wxUSE_WIZARDDLG}{Use \helpref{wxWizard}{wxwizard} class.}
 \twocolitem{wxUSE_WXHTML_HELP}{Use \helpref{wxHtmlHelpController}{wxhtmlhelpcontroller} and related classes.}
 \twocolitem{wxUSE_XML}{Use XML parsing classes.}
 \twocolitem{wxUSE_XPM}{Enable XPM reader for \helpref{wxImage}{wximage} and \helpref{wxBitmap}{wxbitmap} classes.}
 \twocolitem{wxUSE_XRC}{Use XRC XML-based resource system.}
 \twocolitem{wxUSE_ZIPSTREAM}{Enable streams for Zip files.}
 \twocolitem{wxUSE_ZLIB}{Use \helpref{wxZlibInput}{wxzlibinputstream} and \helpref{wxZlibOutputStream}{wxzliboutputstream} classes, required by wxUSE_LIBPNG.}
 @section wxusedefunix wxUSE preprocessor symbols used only under Unix platforms
 \twocolitem{wxUSE_EPOLL_DISPATCHER}{Use wxEpollDispatcher class. See also wxUSE_SELECT_DISPATCHER.}
 \twocolitem{wxUSE_GSTREAMER}{Use GStreamer library in \helpref{wxMediaCtrl}{wxmediactrl}.}
 \twocolitem{wxUSE_LIBMSPACK}{Use libmspack library.}
 \twocolitem{wxUSE_LIBSDL}{Use SDL for wxSound implementation.}
 \twocolitem{wxUSE_PLUGINS}{See also wxUSE_LIBSDL.}
 \twocolitem{wxUSE_UNIX}{Enabled on Unix Platform.}
 @section wxusedefx11 wxUSE preprocessor symbols used only in wxX11 Platform
 \twocolitem{wxUSE_NANOX}{Use NanoX.}
 \twocolitem{wxUSE_UNIV_TEXTCTRL}{Use wxUniv's implementation of \helpref{wxTextCtrl}{wxtextctrl} class.}
 @section wxusedefgtk wxUSE preprocessor symbols used only in wxGTK port
 \twocolitem{wxUSE_DETECT_SM}{Use code to detect X11 session manager.}
 \twocolitem{wxUSE_GTKPRINT}{Use GTK+ printing support.}
 \twocolitem{wxUSE_LIBGNOMEPRINT}{Use GNOME printing support.}
 \twocolitem{wxUSE_LIBGNOMEVFS}{Use GNOME VFS support. Currently has no effect. }
 \twocolitem{wxUSE_LIBHILDON}{Use Hildon framework for Nokia 770. Currently has no effect. }
 @section wxusedefmac wxUSE preprocessor symbols used only in wxMac port
 \twocolitem{wxUSE_MAC_CRITICAL_REGION_MUTEX}{See src/mac/carbon/thread.cpp file.}
 \twocolitem{wxUSE_MAC_PTHREADS_MUTEX}{See src/mac/carbon/thread.cpp file.}
 \twocolitem{wxUSE_MAC_SEMAPHORE_MUTEX}{See src/mac/carbon/thread.cpp file.}
 \twocolitem{wxUSE_WEBKIT}{Use wxWebKitCtrl class.}
 @section wxusedefmotif wxUSE preprocessor symbols used only in wxMotif port
 \twocolitem{wxUSE_GADGETS}{Use xmCascadeButtonGadgetClass, xmLabelGadgetClass, xmPushButtonGadgetClass and xmToggleButtonGadgetClass classes.}
 \twocolitem{wxUSE_INVISIBLE_RESIZE}{See src/motif/dialog.cpp file.}
 @section wxusedefcocoa wxUSE preprocessor symbols used only in Cocoa port
 \twocolitem{wxUSE_OBJC_UNIQUIFYING}{Enable Objective-C class name uniquifying.}
 @section wxusedefos2 wxUSE preprocessor symbols used only in OS2 port
 \twocolitem{wxUSE_CONSOLEDEBUG}{See src/os2/app.cpp file.}
 \twocolitem{wxUSE_DDE}{See src/os2/mimetype.cpp file.}
 \twocolitem{wxUSE_IMAGE_LOADING_IN_MSW}{See src/os2/clipbrd.cpp file.}
 \twocolitem{wxUSE_IMAGE_LOADING_IN_OS2}{See src/os2/gdiimage.cpp file.}
 \twocolitem{wxUSE_NET_API}{Use NetBios32GetInfo API call.}
 \twocolitem{wxUSE_RESOURCE_LOADING_IN_OS2}{See src/os2/gdiimage.cpp file.}
 @section wxusedefmsw wxUSE preprocessor symbols used only in wxMSW port
 \twocolitem{wxUSE_ACCESSIBILITY}{Enable accessibility support}
 \twocolitem{wxUSE_ACTIVEX}{Use \helpref{wxActiveXContainer}{wxactivexcontainer} and related classes.}
 \twocolitem{wxUSE_COMBOCTRL_POPUP_ANIMATION}{See wx/msw/combo.h file.}
 \twocolitem{wxUSE_COMCTL32_SAFELY}{See src/msw/treectrl.cpp file.}
 \twocolitem{wxUSE_COMMON_DIALOGS}{Enable use of windows common dialogs from header commdlg.h; example PRINTDLG.}
 \twocolitem{wxUSE_CRASHREPORT}{Use wxCrashReport class.}
 \twocolitem{wxUSE_DATEPICKCTRL_GENERIC}{Use generic \helpref{wxDatePickerCtrl}{wxdatepickerctrl} implementation in addition to the native one.}
 \twocolitem{wxUSE_DC_CACHEING}{cache temporary \helpref{wxDC}{wxdc} objects.}
 \twocolitem{wxUSE_DIRECTDRAW}{Enable use of the system include file ddraw.h.}
 \twocolitem{wxUSE_DDE_FOR_IPC}{See wx/ipc.h file.}
 \twocolitem{wxUSE_ENH_METAFILE}{Use wxEnhMetaFile.}
 \twocolitem{wxUSE_HOTKEY}{Use \helpref{wxWindow::RegisterHotKey()}{wxwindowregisterhotkey} and \helpref{UnregisterHotKey}{wxwindowunregisterhotkey}}
 \twocolitem{wxUSE_INKEDIT}{Use InkEdit library. Related to Tablet PCs.}
 \twocolitem{wxUSE_MS_HTML_HELP}{Use \helpref{wxCHMHelpController}{wxhelpcontroller} class.}
 \twocolitem{wxUSE_NO_MANIFEST}{Use to prevent the auto generation, under MSVC, of manifest file needed by windows XP and above.}
 \twocolitem{wxUSE_NORLANDER_HEADERS}{Using headers whose author is Anders Norlander.}
 \twocolitem{wxUSE_OLE}{Enables OLE helper routines.}
 \twocolitem{wxUSE_OLE_AUTOMATION}{Enable OLE automation utilities.}
 \twocolitem{wxUSE_OLE_CLIPBOARD}{Use OLE clipboard.}
 \twocolitem{wxUSE_PENWINDOWS}{See src/msw/penwin.cpp file.}
 \twocolitem{wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW}{Use PS printing in wxMSW.}
 \twocolitem{wxUSE_PS_PRINTING}{See src/msw/dcprint.cpp file.}
 \twocolitem{wxUSE_REGKEY}{Use \helpref{wxRegKey}{wxregkey} class.}
 \twocolitem{wxUSE_RICHEDIT}{Enable use of riched32.dll in \helpref{wxTextCtrl}{wxtextctrl}}
 \twocolitem{wxUSE_RICHEDIT2}{Enable use of riched20.dll in \helpref{wxTextCtrl}{wxtextctrl}}
 \twocolitem{wxUSE_VC_CRTDBG}{See wx/msw/msvcrt.h file.}
 \twocolitem{wxUSE_UNICODE_MSLU}{Use MSLU for Unicode support under Windows 9x systems.}
 \twocolitem{wxUSE_UXTHEME}{Enable support for XP themes.}
 \twocolitem{wxUSE_WIN_METAFILES_ALWAYS}{Use \helpref{wxMetaFile}{wxmetafile} even when wxUSE_ENH_METAFILE=$1$.}
 \twocolitem{wxUSE_WXDIB}{Use wxDIB class.}
 \twocolitem{wxUSE_XPM_IN_MSW}{See also wxUSE_XPM}
 @section wxusedefuniv wxUSE preprocessor symbols used only in wxUniversal
 \twocolitem{wxUSE_ALL_THEMES}{Use all themes in wxUniversal; See wx/univ/theme.h file.}
 \twocolitem{wxUSE_THEME_GTK}{Use GTK+ 1-like theme in wxUniversal}
 \twocolitem{wxUSE_THEME_METAL}{Use GTK+ 2-like theme in wxUniversal}
 \twocolitem{wxUSE_THEME_MONO}{Use simple monochrome theme in wxUniversal}
 \twocolitem{wxUSE_THEME_WIN32}{Use Win32-like theme in wxUniversal}
 */
--- a/docs/doxygen/constants.h
+++ b/docs/doxygen/constants.h
@@ -11,13 +11,14 @@
 @page constants_page Constants
 This chapter describes the constants defined by wxWidgets.
 @li @ref cppconst
-
+ @li @ref keycodes
-
+ @li @ref keymodifiers
- <hr>
+ @li @ref languagecodes
-
+ @li @ref stdevtid
-
+ @li @ref stockitems
- @section cppconst Preprocessor symbols defined by wxWidgets
+ @li @ref wxusedef
 */
--- a/docs/doxygen/copyright.h
+++ b/docs/doxygen/copyright.h
@@ -255,7 +255,6 @@
 distribute such modifications or work under the terms of Section 1
 above, provided that you also meet all of these conditions:
 \begin{indented}{1cm}
 a) The modified work must itself be a software library.
 b) You must cause the files modified to carry prominent notices
@@ -278,7 +277,6 @@
 application-supplied function or table used by this function must
 be optional: if the application does not supply it, the square
 root function must still compute square roots.)
 \end{indented}
 These requirements apply to the modified work as a whole. If
 identifiable sections of that work are not derived from the Library,
@@ -376,7 +374,6 @@
 directing the user to the copy of this License. Also, you must do one
 of these things:
 \begin{indented}{1cm}
 a) Accompany the work with the complete corresponding
 machine-readable source code for the Library including whatever
 changes were used in the work (which must be distributed under
@@ -400,7 +397,6 @@
 d) Verify that the user has already received a copy of these
 materials or that you have already sent this user a copy.
 \end{indented}
 For an executable, the required form of the "work that uses the
 Library" must include any data and utility programs needed for
@@ -424,7 +420,6 @@
 the Library and of the other library facilities is otherwise
 permitted, and provided that you do these two things:
 \begin{indented}{1cm}
 a) Accompany the combined library with a copy of the same work
 based on the Library, uncombined with any other library
 facilities. This must be distributed under the terms of the
@@ -433,7 +428,6 @@
 b) Give prominent notice with the combined library of the fact
 that part of it is a work based on the Library, and explaining
 where to find the accompanying uncombined form of the same work.
 \end{indented}
 8. You may not copy, modify, sublicense, link with, or distribute
 the Library except as expressly provided under this License. Any
@@ -521,9 +515,9 @@
 of all derivatives of our free software and of promoting the sharing
 and reuse of software generally.
- \begin{center}
+ <center>
 NO WARRANTY
- \end{center}
+ </center>
 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
 WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
--- a/docs/doxygen/devtips.h
+++ b/docs/doxygen/devtips.h
@@ -31,7 +31,7 @@
 @section includefiles Include files
- The main include file is {\tt "wx/wx.h"}; this includes the most commonly
+ The main include file is @c "wx/wx.h"; this includes the most commonly
 used modules of wxWidgets.
 To save on compilation time, include only those header files relevant to the
@@ -54,7 +54,7 @@
 ... now your other include files ...
 @endverbatim
- The file {\tt "wx/wxprec.h"} includes {\tt "wx/wx.h"}. Although this incantation
+ The file @c "wx/wxprec.h" includes @c "wx/wx.h". Although this incantation
 may seem quirky, it is in fact the end result of a lot of experimentation,
 and several Windows compilers to use precompilation which is largely automatic for
 compilers with necessary support. Currently it is used for Visual C++ (including
@@ -69,8 +69,7 @@
 Most ports of wxWidgets can create either a static library or a shared
 library. wxWidgets can also be built in multilib and monolithic variants.
- See the \helpref{libraries list}{librarieslist} for more
+ See the @ref librarieslist for more information on these.
 information on these.
@@ -78,10 +77,10 @@
 When using project files and makefiles directly to build wxWidgets,
 options are configurable in the file
- \rtfsp{\tt "wx/XXX/setup.h"} where XXX is the required platform (such as msw, motif, gtk, mac). Some
+ @c "wx/XXX/setup.h" where XXX is the required platform (such as msw, motif, gtk, mac). Some
 settings are a matter of taste, some help with platform-specific problems, and
 others can be set to minimize the size of the library. Please see the setup.h file
- and {\tt install.txt} files for details on configuration.
+ and @c install.txt files for details on configuration.
 When using the 'configure' script to configure wxWidgets (on Unix and other platforms where
 configure is available), the corresponding setup.h files are generated automatically
@@ -148,20 +147,20 @@
 The icon can then be referenced by name when creating a frame icon. See
 the MS Windows SDK documentation.
- \normalbox{Note: include wx.rc {\it after} any ICON statements
+ @note include wx.rc @e after any ICON statements
- so programs that search your executable for icons (such
+       so programs that search your executable for icons (such
- as the Program Manager) find your application icon first.}
+       as the Program Manager) find your application icon first.
 @section allocatingobjects Allocating and deleting wxWidgets objects
 In general, classes derived from wxWindow must dynamically allocated
- with {\it new} and deleted with {\it delete}. If you delete a window,
+ with @e new and deleted with @e delete. If you delete a window,
 all of its children and descendants will be automatically deleted,
 so you don't need to delete these descendants explicitly.
- When deleting a frame or dialog, use {\bf Destroy} rather than {\bf delete} so
+ When deleting a frame or dialog, use @b Destroy rather than @b delete so
 that the wxWidgets delayed deletion can take effect. This waits until idle time
 (when all messages have been processed) to actually delete the window, to avoid
 problems associated with the GUI sending events to deleted windows.
@@ -171,7 +170,7 @@
 If you decide to allocate a C++ array of objects (such as wxBitmap) that may
 be cleaned up by wxWidgets, make sure you delete the array explicitly
- before wxWidgets has a chance to do so on exit, since calling {\it delete} on
+ before wxWidgets has a chance to do so on exit, since calling @e delete on
 array members will cause memory problems.
 wxColour can be created statically: it is not automatically cleaned
@@ -204,7 +203,7 @@
 as well).
 The macros handling bit-swapping with respect to the applications endianness
- are described in the \helpref{Byte order macros}{byteordermacros} section.
+ are described in the @ref byteordermacros section.
@@ -213,8 +212,8 @@
 One of the purposes of wxWidgets is to reduce the need for conditional
 compilation in source code, which can be messy and confusing to follow.
 However, sometimes it is necessary to incorporate platform-specific
- features (such as metafile use under MS Windows). The \helpref{wxUSE\_*}{wxusedef}
+ features (such as metafile use under MS Windows). The @ref wxusedef
- symbols listed in the file {\tt setup.h} may be used for this purpose,
+ symbols listed in the file @c setup.h may be used for this purpose,
 along with any user-supplied ones.
@@ -240,11 +239,9 @@
 occurrences of NULL in the GTK+ port use an explicit conversion such
 as
- {\small
+ @code
 @verbatim
   wxWindow *my_window = (wxWindow*) NULL;
- @endverbatim
+ @endcode
 }%
 It is recommended to adhere to this in all code using wxWidgets as
 this make the code (a bit) more portable.
@@ -253,7 +250,7 @@
 Some compilers, such as Borland C++ and Microsoft C++, support
 precompiled headers. This can save a great deal of compiling time. The
- recommended approach is to precompile {\tt "wx.h"}, using this
+ recommended approach is to precompile @c "wx.h", using this
 precompiled header for compiling both wxWidgets itself and any
 wxWidgets applications. For Windows compilers, two dummy source files
 are provided (one for normal applications and one for creating DLLs)
@@ -263,14 +260,14 @@
 is that to take advantage of the facility, you often need to include
 more header files than would normally be the case. This means that
 changing a header file will cause more recompilations (in the case of
- wxWidgets, everything needs to be recompiled since everything includes {\tt "wx.h"}!)
+ wxWidgets, everything needs to be recompiled since everything includes @c "wx.h" !)
 A related problem is that for compilers that don't have precompiled
 headers, including a lot of header files slows down compilation
 considerably. For this reason, you will find (in the common
 X and Windows parts of the library) conditional
 compilation that under Unix, includes a minimal set of headers;
- and when using Visual C++, includes {\tt wx.h}. This should help provide
+ and when using Visual C++, includes @c wx.h. This should help provide
 the optimal compilation for each compiler, although it is
 biased towards the precompiled headers facility available
 in Microsoft C++.
@@ -286,9 +283,9 @@
 One approach is to store filenames on their own, with no directory
 information. The application then searches into a list of standard
- paths (platform-specific) through the use of \helpref{wxStandardPaths}{wxstandardpaths}.
+ paths (platform-specific) through the use of wxStandardPaths.
- Eventually you may want to use also the \helpref{wxPathList}{wxpathlist} class.
+ Eventually you may want to use also the wxPathList class.
 Nowadays the limitations of DOS 8+3 filenames doesn't apply anymore.
 Most modern operating systems allow at least 255 characters in the filename;
@@ -303,166 +300,12 @@
 Also, for text files, different OSes use different End Of Lines (EOL).
 Windows uses CR+LF convention, Linux uses LF only, Mac CR only.
- The \helpref{wxTextFile}{wxtextfile},\helpref{wxTextInputStream}{wxtextinputstream},
+ The wxTextFile, wxTextInputStream, wxTextOutputStream classes help to abstract
 \helpref{wxTextOutputStream}{wxtextoutputstream} classes help to abstract
 from these differences.
- Of course, there are also 3rd party utilities such as \tt{dos2unix} and \tt{unix2dos}
+ Of course, there are also 3rd party utilities such as @c dos2unix and @c unix2dos
 which do the EOL conversions.
- See also the \helpref{File Functions}{filefunctions} section of the reference
+ See also the @ref filefunctions section of the reference
 manual for the description of miscellaneous file handling functions.
 */
 /*!
 @page utilities_page Utilities and libraries supplied with wxWidgets
 In addition to the \helpref{wxWidgets libraries}{librarieslist}, some
 additional utilities are supplied in the \tt{utils} hierarchy.
 For other user-contributed packages, please see the Contributions page
 on the \urlref{wxWidgets Web site}{http://www.wxwidgets.org}.
 \begin{description}\itemsep=0pt
 \item[{\bf Helpview}]
 Helpview is a program for displaying wxWidgets HTML
 Help files. In many cases, you may wish to use the wxWidgets HTML
 Help classes from within your application, but this provides a
 handy stand-alone viewer. See \helpref{wxHTML Notes}{wxhtml} for more details.
 You can find it in {\tt samples/html/helpview}.
 \item[{\bf Tex2RTF}]
 Supplied with wxWidgets is a utility called Tex2RTF for converting\rtfsp
 \LaTeX\ manuals HTML, MS HTML Help, wxHTML Help, RTF, and Windows
 Help RTF formats. Tex2RTF is used for the wxWidgets manuals and can be used independently
 by authors wishing to create on-line and printed manuals from the same\rtfsp
 \LaTeX\ source. Please see the separate documentation for Tex2RTF.
 You can find it under {\tt utils/tex2rtf}.
 \item[{\bf Helpgen}]
 Helpgen takes C++ header files and generates a Tex2RTF-compatible
 documentation file for each class it finds, using comments as appropriate.
 This is a good way to start a reference for a set of classes.
 Helpgen can be found in {\tt utils/HelpGen}.
 \item[{\bf Emulator}]
 Xnest-based display emulator for X11-based PDA applications. On some
 systems, the Xnest window does not synchronise with the
 'skin' window. This program can be found in {\tt utils/emulator}.
 \end{description}
 */
 /*!
 @page strategies_page Programming strategies
 This chapter is intended to list strategies that may be useful when
 writing and debugging wxWidgets programs. If you have any good tips,
 please submit them for inclusion here.
 @li @ref reducingerrors
 @li @ref cpp
 @li @ref portability
 @li @ref debugstrategies
 <hr>
 @section reducingerrors Strategies for reducing programming errors
 @subsection useassert Use ASSERT
 It is good practice to use ASSERT statements liberally, that check for conditions
 that should or should not hold, and print out appropriate error messages.
 These can be compiled out of a non-debugging version of wxWidgets
 and your application. Using ASSERT is an example of `defensive programming':
 it can alert you to problems later on.
 See \helpref{wxASSERT}{wxassert} for more info.
 @subsection usewxstring Use wxString in preference to character arrays
 Using \helpref{wxString}{wxstring} can be much safer and more convenient than using wxChar *.
 You can reduce the possibility of memory leaks substantially, and it is much more
 convenient to use the overloaded operators than functions such as \tt{strcmp}.
 wxString won't add a significant overhead to your program; the overhead is compensated
 for by easier manipulation (which means less code).
 The same goes for other data types: use classes wherever possible.
 @section portability Strategies for portability
 @subsection usesizers Use sizers
 Don't use absolute panel item positioning if you can avoid it. Different GUIs have
 very differently sized panel items. Consider using the \helpref{sizers}{sizeroverview} instead.
 @subsection useresources Use wxWidgets resource files
 Use .xrc (wxWidgets resource files) where possible, because they can be easily changed
 independently of source code. See the \helpref{XRC overview}{xrcoverview} for more info.
 @section debugstrategies Strategies for debugging
 @subsection positivethinking Positive thinking
 It is common to blow up the problem in one's imagination, so that it seems to threaten
 weeks, months or even years of work. The problem you face may seem insurmountable:
 but almost never is. Once you have been programming for some time, you will be able
 to remember similar incidents that threw you into the depths of despair. But
 remember, you always solved the problem, somehow!
 Perseverance is often the key, even though a seemingly trivial problem
 can take an apparently inordinate amount of time to solve. In the end,
 you will probably wonder why you worried so much. That's not to say it
 isn't painful at the time. Try not to worry -- there are many more important
 things in life.
 @subsection simplifyproblem Simplify the problem
 Reduce the code exhibiting the problem to the smallest program possible
 that exhibits the problem. If it is not possible to reduce a large and
 complex program to a very small program, then try to ensure your code
 doesn't hide the problem (you may have attempted to minimize the problem
 in some way: but now you want to expose it).
 With luck, you can add a small amount of code that causes the program
 to go from functioning to non-functioning state. This should give a clue
 to the problem. In some cases though, such as memory leaks or wrong
 deallocation, this can still give totally spurious results!
 @subsection usedebugger Use a debugger
 This sounds like facetious advice, but it is surprising how often people
 don't use a debugger. Often it is an overhead to install or learn how to
 use a debugger, but it really is essential for anything but the most
 trivial programs.
 @subsection uselogging Use logging functions
 There is a variety of logging functions that you can use in your program:
 see \helpref{Logging functions}{logfunctions}.
 Using tracing statements may be more convenient than using the debugger
 in some circumstances (such as when your debugger doesn't support a lot
 of debugging code, or you wish to print a bunch of variables).
 @subsection usedebuggingfacilities Use the wxWidgets debugging facilities
 You can use \helpref{wxDebugContext}{wxdebugcontext} to check for
 memory leaks and corrupt memory: in fact in debugging mode, wxWidgets will
 automatically check for memory leaks at the end of the program if wxWidgets is suitably
 configured. Depending on the operating system and compiler, more or less
 specific information about the problem will be logged.
 You should also use \helpref{debug macros}{debugmacros} as part of a `defensive programming' strategy,
 scattering wxASSERTs liberally to test for problems in your code as early as possible. Forward thinking
 will save a surprising amount of time in the long run.
 See the \helpref{debugging overview}{debuggingoverview} for further information.
 */
--- a/docs/doxygen/introduction.h
+++ b/docs/doxygen/introduction.h
@@ -35,7 +35,8 @@
 Julian Smart, Robert Roebling, Vadim Zeitlin, Vaclav Slavik and many others.
 This manual contains a class reference and topic overviews.
- For a selection of wxWidgets tutorials, please see the documentation page on the \urlref{wxWidgets web site}{http://www.wxwidgets.org}.
+ For a selection of wxWidgets tutorials, please see the documentation page 
 on the wxWidgets web site: http://www.wxwidgets.org.
 Please note that in the following, ``MS Windows" often refers to all
 platforms related to Microsoft Windows, including 32-bit and 64-bit
@@ -48,12 +49,10 @@
 class libraries already existed for cross-platform development,
 none met all of the following criteria:
- \begin{enumerate}\itemsep=0pt
+ @li low price;
- \item low price;
+ @li source availability;
- \item source availability;
+ @li simplicity of programming;
- \item simplicity of programming;
+ @li support for a wide range of compilers.
 \item support for a wide range of compilers.
 \end{enumerate}
 Since wxWidgets was started, several other free or almost-free
 GUI frameworks have emerged. However, none has the range of
@@ -94,33 +93,32 @@
 It is impossible to sum up the functionality of wxWidgets in a few paragraphs, but
 here are some of the benefits:
- \begin{itemize}\itemsep=0pt
+ @li Low cost (free, in fact!)
- \item Low cost (free, in fact!)
+ @li You get the source.
- \item You get the source.
+ @li Available on a variety of popular platforms.
- \item Available on a variety of popular platforms.
+ @li Works with almost all popular C++ compilers and Python.
- \item Works with almost all popular C++ compilers and Python.
+ @li Over 70 example programs.
- \item Over 70 example programs.
+ @li Over 1000 pages of printable and on-line documentation.
- \item Over 1000 pages of printable and on-line documentation.
+ @li Simple-to-use, object-oriented API.
- \item Simple-to-use, object-oriented API.
+ @li Flexible event system.
- \item Flexible event system.
+ @li Graphics calls include lines, rounded rectangles, splines, polylines, etc.
- \item Graphics calls include lines, rounded rectangles, splines, polylines, etc.
+ @li Constraint-based and sizer-based layouts.
- \item Constraint-based and sizer-based layouts.
+ @li Print/preview and document/view architectures.
- \item Print/preview and document/view architectures.
+ @li Toolbar, notebook, tree control, advanced list control classes.
- \item Toolbar, notebook, tree control, advanced list control classes.
+ @li PostScript generation under Unix, normal MS Windows printing on the PC.
- \item PostScript generation under Unix, normal MS Windows printing on the PC.
+ @li MDI (Multiple Document Interface) support.
- \item MDI (Multiple Document Interface) support.
+ @li Can be used to create DLLs under Windows, dynamic libraries on Unix.
- \item Can be used to create DLLs under Windows, dynamic libraries on Unix.
+ @li Common dialogs for file browsing, printing, colour selection, etc.
- \item Common dialogs for file browsing, printing, colour selection, etc.
+ @li Under MS Windows, support for creating metafiles and copying them to the clipboard.
- \item Under MS Windows, support for creating metafiles and copying
+ @li An API for invoking help from applications.
- them to the clipboard.
+ @li Ready-to-use HTML window (supporting a subset of HTML).
- \item An API for invoking help from applications.
+ @li Network support via a family of socket and protocol classes.
- \item Ready-to-use HTML window (supporting a subset of HTML).
+ @li Support for platform independent image processing.
- \item Network support via a family of socket and protocol classes.
+ @li Built-in support for many file formats (BMP, PNG, JPEG, GIF, XPM, PNM, PCX).
- \item Support for platform independent image processing.
+ @li Includes Tex2RTF, to allow you to produce your own documentation
- \item Built-in support for many file formats (BMP, PNG, JPEG, GIF, XPM, PNM, PCX).
+     in Windows Help, HTML and Word RTF formats.
- \item Includes Tex2RTF, to allow you to produce your own documentation
+
- in Windows Help, HTML and Word RTF formats.
+
 \end{itemize}
 @section requirements wxWidgets requirements
@@ -128,69 +126,62 @@
 (a) MS-Windows:
- \begin{enumerate}\itemsep=0pt
+ @li A 32-bit or 64-bit PC running MS Windows.
- \item A 32-bit or 64-bit PC running MS Windows.
+ @li A Windows compiler: MS Visual C++ (embedded Visual C++ for wxWinCE
- \item A Windows compiler: MS Visual C++ (embedded Visual C++ for wxWinCE
+     port), Borland C++, Watcom C++, Cygwin, MinGW, Metrowerks CodeWarrior,
- port), Borland C++, Watcom C++, Cygwin, MinGW, Metrowerks CodeWarrior,
+     Digital Mars C++. See @c install.txt for details about compiler
- Digital Mars C++. See {\tt install.txt} for details about compiler
+     version supported.
 version supported.
 \end{enumerate}
 (b) Unix:
- \begin{enumerate}\itemsep=0pt
+ @li Almost any C++ compiler, including GNU C++ and many Unix vendors
- \item Almost any C++ compiler, including GNU C++ and many Unix vendors
+     compilers such as Sun CC, HP-UX aCC or SGI mipsPro.
- compilers such as Sun CC, HP-UX aCC or SGI mipsPro.
+ @li Almost any Unix workstation, and one of: GTK+ 2.4 or higher (GTK+ 1.2.10
- \item Almost any Unix workstation, and one of: GTK+ 2.4 or higher (GTK+ 1.2.10
+     may still be supported but wxGTK1 port is not maintained any longer and lacks
- may still be supported but wxGTK1 port is not maintained any longer and lacks
+     many features of wxGTK2), Motif 1.2 or higher or Lesstif. If using the wxX11
- many features of wxGTK2), Motif 1.2 or higher or Lesstif. If using the wxX11
+     port, no such widget set is required.
 port, no such widget set is required.
 \end{enumerate}
 (c) Mac OS/Mac OS X:
- \begin{enumerate}\itemsep=0pt
+ @li A PowerPC or Intel Mac running Mac OS X 10.3 or higher
- \item A PowerPC or Intel Mac running Mac OS X 10.3 or higher
+ @li The Apple Developer Tools (eg. GNU C++) or MetroWerks CodeWarrior (not
- \item The Apple Developer Tools (eg. GNU C++) or MetroWerks CodeWarrior (not
+     actively supported)
 actively supported)
 \end{enumerate}
 Under all platforms it's recommended to have large amounts of free hard disk
 space. The exact amount needed depends on the port, compiler and build
 configurations but to give an example, a debug build of the library may take up
 to 500MB.
 @section where Availability and location of wxWidgets
- \winhelponly{wxWidgets is available by anonymous FTP and World Wide Web
+ wxWidgets is available by anonymous FTP and World Wide Web
- from ftp://biolpc22.york.ac.uk/pub and/or http://www.wxwidgets.org.}
+ from ftp://biolpc22.york.ac.uk/pub and/or http://www.wxwidgets.org.
 \winhelpignore{wxWidgets is available by anonymous FTP and World Wide Web
 from \urlref{ftp://biolpc22.york.ac.uk/pub}{ftp://biolpc22.york.ac.uk/pub}
 and/or \urlref{http://www.wxwidgets.org}{http://www.wxwidgets.org}.}
 You can also buy a CD-ROM using the form on the Web site.
 @section acknowledgements Acknowledgements
 The following is the list of the core, active developers of wxWidgets which keep
 it running and have provided an invaluable, extensive and high-quality amount of
 changes over the many of years of wxWidgets' life:
- \begin{description}\itemsep=0pt
+ @li Julian Smart
- \item Julian Smart
+ @li Vadim Zeitlin
- \item Vadim Zeitlin
+ @li Robert Roebling
- \item Robert Roebling
+ @li Robin Dunn
- \item Robin Dunn
+ @li Stefan Csomor
- \item Stefan Csomor
+ @li Vaclav Slavik
- \item Vaclav Slavik
+ @li Paul Cornett
- \item Paul Cornett
+ @li Wlodzimierz `ABX' Skiba
- \item Wlodzimierz `ABX' Skiba
+ @li Chris Elliott
- \item Chris Elliott
+ @li David Elliott
- \item David Elliott
+ @li Kevin Hock
- \item Kevin Hock
+ @li Stefan Neis
- \item Stefan Neis
+ @li Michael Wetherell
 \item Michael Wetherell
 \end{description}
 We would particularly like to thank the following peoples for their contributions
 to wxWidgets, and the many others who have been involved in the project over the years.
@@ -206,11 +197,11 @@
 Stefan Gunter, Bill Hale, Patrick Halke, Stefan Hammes, Guillaume Helle,
 Harco de Hilster, Cord Hockemeyer, Markus Holzem, Olaf Klein, Leif Jensen,
 Bart Jourquin, Guilhem Lavaux, Ron Lee, Jan Lessner, Nicholas Liebmann,
- Torsten Liermann, Per Lindqvist, Francesco Montorsi, Thomas Runge, Tatu M\"{a}nnist\"{o},
+ Torsten Liermann, Per Lindqvist, Francesco Montorsi, Thomas Runge, Tatu M&auml;nnist&ouml;,
 Scott Maxwell, Thomas Myers, Oliver Niedung, Ryan Norton, Hernan Otero,
 Ian Perrigo, Timothy Peters, Giordano Pezzoli, Harri Pasanen, Thomaso Paoletti,
 Garrett Potts, Marcel Rasche, Dino Scaringella, Jobst Schmalenbach, Arthur Seaton,
- Paul Shirley, Stein Somers, Petr Smilauer, Neil Smith, Kari Syst\"{a}, George Tasker,
+ Paul Shirley, Stein Somers, Petr Smilauer, Neil Smith, Kari Syst&auml;, George Tasker,
 Arthur Tetzlaff-Deas, Jonathan Tonberg, Jyrki Tuomi, Janos Vegh, Andrea Venturoli,
 David Webster, Otto Wyss, Xiaokun Zhu, Edward Zimmermann.
@@ -225,7 +216,8 @@
 from the source of which we have borrowed some spline drawing code.
 His copyright is included below.
- {\it XFig2.1 is copyright (c) 1985 by Supoj Sutanthavibul. Permission to
+ <em>
 XFig2.1 is copyright (c) 1985 by Supoj Sutanthavibul. Permission to
 use, copy, modify, distribute, and sell this software and its
 documentation for any purpose is hereby granted without fee, provided
 that the above copyright notice appear in all copies and that both that
@@ -234,6 +226,7 @@
 publicity pertaining to distribution of the software without specific,
 written prior permission.  M.I.T. makes no representations about the
 suitability of this software for any purpose.  It is provided ``as is''
- without express or implied warranty.}
+ without express or implied warranty.
 </em>
 */
--- a/docs/doxygen/libs.h
+++ b/docs/doxygen/libs.h
@@ -12,8 +12,8 @@
 @page libraries_page Libraries list
 wxWidgets can be built either as a single large
- library (this is called the {\it monolithic build}) or as several smaller
+ library (this is called the <em>monolithic build</em>) or as several smaller
- libraries ({\it multilib build}). Multilib build is the default.
+ libraries (<em>multilib build</em>}). Multilib build is the default.
 wxWidgets library is divided into libraries briefly described below. This
 diagram show dependencies between them:
@@ -21,17 +21,18 @@
 @image html libs.gif
 Please note that arrows indicate the "depends from" relation and that
- all blue boxes depend from wxBase library (i.e. they are non-GUI libraries), and
+ all blue boxes depend from wxBase library (i.e. they are non-GUI libraries),
- all green boxes depend from wxCore library (i.e. they are GUI libraries).
+ and all green boxes depend from wxCore library (i.e. they are GUI libraries).
 @section wxBase wxBase
 Every wxWidgets application must link against this library. It contains
- mandatory classes that any wxWidgets code depends on (e.g.
+ mandatory classes that any wxWidgets code depends on (e.g. wxString) and
-  \helpref{wxString}{wxstring}) and portability classes that abstract
+ portability classes that abstract differences between platforms.
- differences between platforms. wxBase can be used to develop console mode
+ wxBase can be used to develop console mode applications, it does not require
- applications, it does not require any GUI libraries or running X Window System
+ any GUI libraries or running X Window System on Unix.
- on Unix.
+
 @section wxCore wxCore
@@ -41,103 +42,103 @@
 Requires wxBase.
 @section wxAui wxAui
 This contains the Advanced User Interface docking library.
 Requires wxAdvanced, wxHTML, wxXML, wxCore, wxBase.
 @section wxNet wxNet
 Classes for network access:
- \begin{itemize}
+ @li wxSocket classes (wxSocketClient, wxSocketServer and related classes)
- \item{ wxSocket classes (\helpref{wxSocketClient}{wxsocketclient},
+ @li wxSocketOutputStream and wxSocketInputStream
-  \helpref{wxSocketServer}{wxsocketserver} and related classes) }
+ @li sockets-based IPC classes (wxTCPServer, wxTCPClient and wxTCPConnection)
- \item{ \helpref{wxSocketOutputStream}{wxsocketoutputstream} and
+ @li wxURL
-  \helpref{wxSocketInputStream}{wxsocketinputstream} }
+ @li wxInternetFSHandler (a wxFileSystem handler)
 \item{ sockets-based IPC classes (\helpref{wxTCPServer}{wxddeserver},
  \helpref{wxTCPClient}{wxddeclient} and
  \helpref{wxTCPConnection}{wxddeconnection}) }
 \item{ \helpref{wxURL}{wxurl} }
 \item{ wxInternetFSHandler (a \helpref{wxFileSystem handler}{fs}) }
 \end{itemize}
 Requires wxBase.
 @section wxRichText wxRichText
 This contains generic rich text control functionality.
 Requires wxAdvanced, wxHTML, wxXML, wxCore, wxBase.
 @section wxXML wxXML
 This library contains simple classes for parsing XML documents.
 Requires wxBase.
 @section wxAdvanced wxAdvanced
 Advanced or rarely used GUI classes:
- \begin{itemize}\itemsep=0pt
+ @li wxCalendarCtrl
- \item{ \helpref{wxCalendarCtrl}{wxcalendarctrl} }
+ @li wxGrid classes
- \item{ \helpref{wxGrid classes}{gridoverview} }
+ @li wxJoystick
- \item{ \helpref{wxJoystick}{wxjoystick} }
+ @li wxLayoutAlgorithm
- \item{ \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} }
+ @li wxSplashScreen
- \item{ \helpref{wxSplashScreen}{wxsplashscreen} }
+ @li wxTaskBarIcon
- \item{ \helpref{wxTaskBarIcon}{wxtaskbaricon} }
+ @li wxSound
- \item{ \helpref{wxSound}{wxsound} }
+ @li wxWizard
- \item{ \helpref{wxWizard}{wxwizard} }
+ @li wxSashLayoutWindow
- \item{ \helpref{wxSashLayoutWindow}{wxsashlayoutwindow} }
+ @li wxSashWindow
- \item{ \helpref{wxSashWindow}{wxsashwindow} }
+ @li ...others
 \item{ ...others }
 \end{itemize}
 Requires wxCore and wxBase.
 @section wxMedia wxMedia
 Miscellaneous classes related to multimedia. Currently this library only
- contains \helpref{wxMediaCtrl}{wxmediactrl} but more classes will be added in
+ contains wxMediaCtrl but more classes will be added in
 the future.
 Requires wxCore and wxBase.
 @section wxGL wxGL
- This library contains \helpref{wxGLCanvas}{wxglcanvas} class for integrating
+ This library contains wxGLCanvas class for integrating
 OpenGL library with wxWidgets. Unlike all others, this library is {\em not}
-  part of the monolithic library, it is always built as separate library.
+ part of the monolithic library, it is always built as separate library.
 Requires wxCore and wxBase.
 @section wxHTML wxHTML
- Simple HTML renderer and other \helpref{HTML rendering classes}{wxhtml} are
+ Simple HTML renderer and other @ref html_overview are contained in this library, 
- contained in this library, as well as
+ as well as wxHtmlHelpController, wxBestHelpController and wxHtmlListBox.
  \helpref{wxHtmlHelpController}{wxhtmlhelpcontroller},
  \helpref{wxBestHelpController}{wxhelpcontroller} and
  \helpref{wxHtmlListBox}{wxhtmllistbox}.
 Requires wxCore and wxBase.
 @section wxQA wxQA
 This is the library containing extra classes for quality assurance. Currently
- it only contains \helpref{wxDebugReport}{wxdebugreport} and related classes,
+ it only contains wxDebugReport and related classes,
 but more will be added to it in the future.
 Requires wxXML, wxCore, wxBase.
 @section wxXRC wxXRC
- This library contains \helpref{wxXmlResource}{wxxmlresource} class that
+ This library contains wxXmlResource class that
 provides access to XML resource files in XRC format
 Requires wxAdvanced, wxHTML, wxXML, wxCore, wxBase.
 @section wxSTC wxSTC
 STC (Styled Text Control) is a wrapper around Scintilla, a syntax-highlighting text editor.
--- a/docs/doxygen/platdetails.h
+++ b/docs/doxygen/platdetails.h
@@ -18,18 +18,566 @@
 requires. This chapter collects notes about differences among supported platforms
 and ports.
 @li @ref wxgtkport
 @li @ref wxmacport
 @li @ref wxos2port
 @li @ref wxmglport
 @li @ref wxx11port
 @li @ref wxmswport
 @li @ref nativedocs
 <hr>
- \input wxgtk.tex
+
- \input wxmsw.tex
+
- \input wxmac.tex
+ @section wxgtkport wxGTK port
- \input wxpalm.tex
+ 
- \input wxos2.tex
+ wxGTK is a port of wxWidgets using the GTK+ library.
- \input wxmgl.tex
+ It makes use of GTK+'s native widgets wherever possible and uses
- \input wxx11.tex
+ wxWidgets' generic controls when needed. GTK+ itself has been
 ported to a number of systems, but so far only the original X11
 version is supported. Support for other GTK+ backends is planned,
 such as the new DirectFB backend.
 All work is being done on GTK+ version 2.0 and above. Support for
 GTK+ 1.2 will be deprecated in a later release.
 You will need GTK+ 2.0 or higher which is available from:
 http://www.gtk.org
 The newer version of GTK+ you use, the more native widgets and
 features will be utilized. We have gone to a great extent to
 allow compiling wxWidgets applications with a latest version of
 GTK+, with the resulting binary working on systems even with a
 much lower version of GTK+. You will have to ensure that the
 application is launched with lazy symbol binding for that.
 In order to configure wxWidgets to compile wxGTK you will 
 need use the @c --with-gtk argument to the @c configure script.
 This is the default for many systems.
 GTK+ 1.2 can still be used, albeit discouraged. For that you can
 pass @c --with-gtk=1 to the @c configure script.
 For further information, please see the files in docs/gtk
 in the distribution.
 @section wxmacport wxMac port
 wxMac is a port of wxWidgets for the Macintosh OS platform.
 Currently MacOS 8.6 or higher, MacOS 9.0 or higher and
 MacOS X 10.0 or higher are supported, although most development
 effort goes into MacOS X support. wxMac can be compiled both
 using Apple's developer tools and MetroWerks CodeWarrior in
 different versions. Support for MacOS 8.X and MacOS 9.X is
 only available through CodeWarrior. wxMac uses the Carbon
 API (and optionally the Classic API under MacOS 8.X). You
 will need wxWidgets version 2.3.3 or higher for a stable
 version of wxMac.
 For further information, please see the files in docs/mac
 in the distribution.
 @section wxmglport wxMGL port
 wxMGL is a port of wxWidgets using the MGL library available
 from SciTech as the underlying graphics backend. wxMGL draws
 its widgets using the wxUniversal widget set which is now
 part of wxWidgets. MGL itself runs on a variety of platforms
 including DOS, Linux hardware (similar to the Linux framebuffer)
 and various graphics systems such as Win32, X11 and OS/2.
 Note that currently MGL for Linux runs only on x86-based systems.
 You will need wxWidgets 2.3.3 or higher and MGL 5.0 or higher.
 The latter is available from
 http://www.scitechsoft.com/products/product_download.html
 In order to configure wxWidgets to compile wxMGL you will
 need to type:
 @verbatim configure --with-mgl --with-universal @endverbatim
 Under DOS, wxMGL uses a dmake based make system.
 For further information, please see the files in docs/mgl
 in the distribution.
 @section wxos2port wxOS2 port
 wxOS2 is a port of wxWidgets for the IBM OS/2 platform.
 It is currently under construction.
 @section wxx11port wxX11 port
 wxX11 is a port of wxWidgets using X11 (The X Window System)
 as the underlying graphics backend. wxX11 draws its widgets
 using the wxUniversal widget set which is now part of wxWidgets.
 wxX11 is well-suited for a number of special applications such
 as those running on systems with few resources (PDAs) or for
 applications which need to use a special themed look. You will need
 wxWidgets 2.3.2 or higher.
 In order to configure wxWidgets to compile wxX11 you will 
 need to type:
 @verbatim configure --with-x11 --with-universal @endverbatim
 For further information, please see the files in docs/x11
 in the distribution. There is also a page on the use of
 wxWidgets for embedded applications on the wxWidgets web site.
 @section wxmswport wxMSW port
 wxMSW is a port of wxWidgets for the Windows platforms
 including Windows 95, 98, ME, 2000, NT, XP in ANSI and
 Unicode mode (for Windows 95 through the MSLU extension
 library). wxMSW ensures native look and feel for XP
 as well when using wxWidgets version 2.3.3 or higher.
 wxMSW can be compile with a great variety of compilers
 including MS VC++, Borland 5.5, MinGW32, Cygwin and
 Watcom as well as cross-compilation with a Linux hosted
 MinGW32 tool chain.
 For further information, please see the files in docs/msw
 in the distribution.
 @subsection wxmswthemedborders Themed borders on Windows
 Starting with wxWidgets 2.8.5, you can specify the wxBORDER_THEME style to have wxWidgets
 use a themed border. Using the default XP theme, this is a thin 1-pixel blue border,
 with an extra 1-pixel border in the window client background colour (usually white) to
 separate the client area's scrollbars from the border.
 If you don't specify a border style for a wxTextCtrl in rich edit mode, wxWidgets now gives
 the control themed borders automatically, where previously they would take the Windows 95-style
 sunken border. Other native controls such as wxTextCtrl in non-rich edit mode, and wxComboBox,
 already paint themed borders where appropriate. To use themed borders on other windows, such
 as wxPanel, pass the wxBORDER_THEME style, or (apart from wxPanel) pass no border style.
 In general, specifying wxBORDER_THEME will cause a border of some kind to be used, chosen by the platform
 and control class. To leave the border decision entirely to wxWidgets, pass wxBORDER_DEFAULT.
 This is not to be confused with specifying wxBORDER_NONE, which says that there should
 definitely be @e no border.
 @subsubsection wxmswthemedborders_details More detail on border implementation
 The way that wxMSW decides whether to apply a themed border is as follows.
 The theming code calls wxWindow::GetBorder() to obtain a border. If no border style has been
 passed to the window constructor, GetBorder() calls GetDefaultBorder() for this window.
 If wxBORDER_THEME was passed to the window constructor, GetBorder() calls GetDefaultBorderForControl().
 The implementation of wxWindow::GetDefaultBorder() on wxMSW calls wxWindow::CanApplyThemeBorder()
 which is a virtual function that tells wxWidgets whether a control can have a theme
 applied explicitly (some native controls already paint a theme in which case we should not
 apply it ourselves). Note that wxPanel is an exception to this rule because in many cases
 we wish to create a window with no border (for example, notebook pages). So wxPanel
 overrides GetDefaultBorder() in order to call the generic wxWindowBase::GetDefaultBorder(),
 returning wxBORDER_NONE.
 @subsection wxwince wxWinCE
 wxWinCE is the name given to wxMSW when compiled on Windows CE devices;
 most of wxMSW is common to Win32 and Windows CE but there are
 some simplifications, enhancements, and differences in
 behaviour.
 For building instructions, see docs/msw/wince in the
 distribution, also the section about Visual Studio 2005 project
 files below. The rest of this section documents issues you
 need to be aware of when programming for Windows CE devices.
 @subsubsection port_ General issues for wxWinCE programming
 Mobile applications generally have fewer features and
 simpler user interfaces. Simply omit whole sizers, static
 lines and controls in your dialogs, and use comboboxes instead
 of listboxes where appropriate. You also need to reduce
 the amount of spacing used by sizers, for which you can
 use a macro such as this:
 @verbatim
 #if defined(__WXWINCE__)
     #define wxLARGESMALL(large,small) small
 #else
     #define wxLARGESMALL(large,small) large
 #endif
 // Usage
 topsizer->Add( CreateTextSizer( message ), 0, wxALL, wxLARGESMALL(10,0) );
 @endverbatim
 There is only ever one instance of a Windows CE application running,
 and wxWidgets will take care of showing the current instance and
 shutting down the second instance if necessary.
 You can test the return value of wxSystemSettings::GetScreenType()
 for a qualitative assessment of what kind of display is available,
 or use wxGetDisplaySize() if you need more information.
 You can also use wxGetOsVersion to test for a version of Windows CE at
 run-time (see the next section). However, because different builds
 are currently required to target different kinds of device, these
 values are hard-wired according to the build, and you cannot
 dynamically adapt the same executable for different major Windows CE
 platforms. This would require a different approach to the way
 wxWidgets adapts its behaviour (such as for menubars) to suit the
 style of device.
 See the "Life!" example (demos/life) for an example of
 an application that has been tailored for PocketPC and Smartphone use.
 @note don't forget to have this line in your .rc file, as for
       desktop Windows applications:
 @verbatim #include "wx/msw/wx.rc" @endverbatim
 @subsubsection port_ Testing for WinCE SDKs
 Use these preprocessor symbols to test for the different types of device or SDK:
 @li @b __SMARTPHONE__ Generic mobile devices with phone buttons and a small display
 @li @b __PDA__ Generic mobile devices with no phone
 @li @b __HANDHELDPC__ Generic mobile device with a keyboard
 @li @b __WXWINCE__ Microsoft-powered Windows CE devices, whether PocketPC, Smartphone or Standard SDK
 @li @b WIN32_PLATFORM_WFSP Microsoft-powered smartphone
 @li @b __POCKETPC__ Microsoft-powered PocketPC devices with touch-screen
 @li @b __WINCE_STANDARDSDK__ Microsoft-powered Windows CE devices, for generic Windows CE applications
 @li @b __WINCE_NET__ Microsoft-powered Windows CE .NET devices (_WIN32_WCE is 400 or greater)
 wxGetOsVersion will return these values:
 @li @b wxWINDOWS_POCKETPC The application is running under PocketPC.
 @li @b wxWINDOWS_SMARTPHONE The application is running under Smartphone.
 @li @b wxWINDOWS_CE The application is running under Windows CE (built with the Standard SDK).
 @subsubsection port_ Window sizing in wxWinCE
 Top level windows (dialogs, frames) are created always full-screen. Fit() of sizers will not rescale top
 level windows but instead will scale window content.
 If the screen orientation changes, the windows will automatically be resized
 so no further action needs to be taken (unless you want to change the layout
 according to the orientation, which you could detect in idle time, for example).
 When input panel (SIP) is shown, top level windows (frames and dialogs) resize
 accordingly (see wxTopLevelWindow::HandleSettingChange).
 @subsubsection port_ Closing top-level windows in wxWinCE
 You won't get a wxCloseEvent when the user clicks on the X in the titlebar
 on Smartphone and PocketPC; the window is simply hidden instead. However the system may send the
 event to force the application to close down.
 @subsubsection port_ Hibernation in wxWinCE
 Smartphone and PocketPC will send a wxEVT_HIBERNATE to the application object in low
 memory conditions. Your application should release memory and close dialogs,
 and wake up again when the next wxEVT_ACTIVATE or wxEVT_ACTIVATE_APP message is received.
 (wxEVT_ACTIVATE_APP is generated whenever a wxEVT_ACTIVATE event is received
 in Smartphone and PocketPC, since these platforms do not support WM_ACTIVATEAPP.)
 @subsubsection port_ Hardware buttons in wxWinCE
 Special hardware buttons are sent to a window via the wxEVT_HOTKEY event
 under Smartphone and PocketPC. You should first register each required button with 
 wxWindow::RegisterHotKey, and unregister the button when you're done with it. For example:
 @verbatim
   win->RegisterHotKey(0, wxMOD_WIN, WXK_SPECIAL1);
   win->UnregisterHotKey(0);
 @endverbatim
 You may have to register the buttons in a wxEVT_ACTIVATE event handler
 since other applications will grab the buttons.
 There is currently no method of finding out the names of the special
 buttons or how many there are.
 @subsubsection port_ Dialogs in wxWinCE
 PocketPC dialogs have an OK button on the caption, and so you should generally
 not repeat an OK button on the dialog. You can add a Cancel button if necessary, but some dialogs
 simply don't offer you the choice (the guidelines recommend you offer an Undo facility
 to make up for it). When the user clicks on the OK button, your dialog will receive
 a wxID_OK event by default. If you wish to change this, call wxDialog::SetAffirmativeId
 with the required identifier to be used. Or, override wxDialog::DoOK (return @false to
 have wxWidgets simply call Close to dismiss the dialog).
 Smartphone dialogs do @e not have an OK button on the caption, and are closed
 using one of the two menu buttons. You need to assign these using wxTopLevelWindow::SetLeftMenu
 and wxTopLevelWindow::SetRightMenu, for example:
 @verbatim
 #ifdef __SMARTPHONE__
     SetLeftMenu(wxID_OK);
     SetRightMenu(wxID_CANCEL, _("Cancel"));
 #elif defined(__POCKETPC__)
     // No OK/Cancel buttons on PocketPC, OK on caption will close
 #else
     topsizer->Add( CreateButtonSizer( wxOK|wxCANCEL ), 0, wxEXPAND | wxALL, 10 );
 #endif
 @endverbatim
 For implementing property sheets (flat tabs), use a wxNotebook with wxNB_FLAT|wxNB_BOTTOM
 and have the notebook left, top and right sides overlap the dialog by about 3 pixels
 to eliminate spurious borders. You can do this by using a negative spacing in your
 sizer Add() call. The cross-platform property sheet dialog wxPropertySheetDialog is
 provided, to show settings in the correct style on PocketPC and on other platforms.
 Notifications (bubble HTML text with optional buttons and links) will also be
 implemented in the future for PocketPC.
 Modeless dialogs probably don't make sense for PocketPC and Smartphone, since
 frames and dialogs are normally full-screen, and a modeless dialog is normally
 intended to co-exist with the main application frame.
 @subsubsection port_menus_ppc Menubars and toolbars in PocketPC
 On PocketPC, a frame must always have a menubar, even if it's empty.
 An empty menubar/toolbar is automatically provided for dialogs, to hide
 any existing menubar for the duration of the dialog.
 Menubars and toolbars are implemented using a combined control,
 but you can use essentially the usual wxWidgets API; wxWidgets will combine the menubar
 and toolbar. However, there are some restrictions:
 @li You must create the frame's primary toolbar with wxFrame::CreateToolBar,
 because this uses the special wxToolMenuBar class (derived from wxToolBar)
 to implement the combined toolbar and menubar. Otherwise, you can create and manage toolbars
 using the wxToolBar class as usual, for example to implement an optional
 formatting toolbar above the menubar as Pocket Word does. But don't assign
 a wxToolBar to a frame using SetToolBar - you should always use CreateToolBar
 for the main frame toolbar.
 @li Deleting and adding tools to wxToolMenuBar after Realize is called is not supported.
 @li For speed, colours are not remapped to the system colours as they are
 in wxMSW. Provide the tool bitmaps either with the correct system button background,
 or with transparency (for example, using XPMs).
 @li Adding controls to wxToolMenuBar is not supported. However, wxToolBar supports
 controls.
 Unlike in all other ports, a wxDialog has a wxToolBar, automatically created
 for you. You may either leave it blank, or access it with wxDialog::GetToolBar
 and add buttons, then calling wxToolBar::Realize. You cannot set or recreate
 the toolbar.
 @subsubsection port_menus_smart Menubars and toolbars in Smartphone
 On Smartphone, there are only two menu buttons, so a menubar is simulated
 using a nested menu on the right menu button. Any toolbars are simply ignored on
 Smartphone.
 @subsubsection port_ Closing windows in wxWinCE
 The guidelines state that applications should not have a Quit menu item,
 since the user should not have to know whether an application is in memory
 or not. The close button on a window does not call the window's
 close handler; it simply hides the window. However, the guidelines say that
 the Ctrl+Q accelerator can be used to quit the application, so wxWidgets
 defines this accelerator by default and if your application handles
 wxID_EXIT, it will do the right thing.
 @subsubsection port_ Context menus in wxWinCE
 To enable context menus in PocketPC, you currently need to call wxWindow::EnableContextMenu,
 a wxWinCE-only function. Otherwise the context menu event (wxContextMenuEvent) will
 never be sent. This API is subject to change.
 Context menus are not supported in Smartphone.
 @subsubsection port_ Control differences on wxWinCE
 These controls and styles are specific to wxWinCE:
 @li wxTextCtrl The wxTE_CAPITALIZE style causes a CAPEDIT control to
 be created, which capitalizes the first letter.
 These controls are missing from wxWinCE:
 @li MDI classes MDI is not supported under Windows CE.
 @li wxMiniFrame Not supported under Windows CE.
 Tooltips are not currently supported for controls, since on PocketPC controls with
 tooltips are distinct controls, and it will be hard to add dynamic
 tooltip support.
 Control borders on PocketPC and Smartphone should normally be specified with
 wxBORDER_SIMPLE instead of wxBORDER_SUNKEN. Controls will usually adapt
 appropriately by virtue of their GetDefaultBorder() function, but if you
 wish to specify a style explicitly you can use wxDEFAULT_CONTROL_BORDER
 which will give a simple border on PocketPC and Smartphone, and the sunken border on
 other platforms.
 @subsubsection port_ Online help in wxWinCE
 You can use the help controller wxWinceHelpController which controls
 simple @c .htm files, usually installed in the Windows directory.
 See the Windows CE reference for how to format the HTML files.
 @subsubsection port_ Installing your PocketPC and Smartphone applications
 To install your application, you need to build a CAB file using
 the parameters defined in a special .inf file. The CabWiz program
 in your SDK will compile the CAB file from the .inf file and
 files that it specifies.
 For delivery, you can simply ask the user to copy the CAB file to the
 device and execute the CAB file using File Explorer. Or, you can
 write a program for the desktop PC that will find the ActiveSync
 Application Manager and install the CAB file on the device,
 which is obviously much easier for the user.
 Here are some links that may help.
 @li A setup builder that takes CABs and builds a setup program is at
     http://www.eskimo.com/~scottlu/win/index.html.
 @li Sample installation files can be found in 
     <tt>Windows CE Tools/wce420/POCKET PC 2003/Samples/Win32/AppInst</tt>.
 @li An installer generator using wxPython can be found at 
     http://ppcquicksoft.iespana.es/ppcquicksoft/myinstall.html.
 @li Miscellaneous Windows CE resources can be found at 
     http://www.orbworks.com/pcce/resources.html.
 @li Installer creation instructions with a setup.exe for installing to PPC can be found at 
     http://www.pocketpcdn.com/articles/creatingsetup.html.
 @li Microsoft instructions are at 
     http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnce30/html/appinstall30.asp?frame=true
 @li Troubleshooting WinCE application installations: 
     http://support.microsoft.com/default.aspx?scid=KB;en-us;q181007
 You may also check out <tt>demos/life/setup/wince</tt> which contains
 scripts to create a PocketPC installation for ARM-based
 devices. In particular, @c build.bat builds the distribution and
 copies it to a directory called @c Deliver.
 @subsubsection port_ wxFileDialog in PocketPC
 Allowing the user to access files on memory cards, or on arbitrary
 parts of the filesystem, is a pain; the standard file dialog only
 shows folders under My Documents or folders on memory cards
 (not the system or card root directory, for example). This is
 a known problem for PocketPC developers.
 If you need a file dialog that allows access to all folders,
 you can use wxGenericFileDialog instead. You will need to include 
 @c wx/generic/filedlgg.h.
 @subsubsection port_ Embedded Visual C++ Issues
 <b>Run-time type information</b>
 If you wish to use runtime type information (RTTI) with eVC++ 4, you need to download
 an extra library, @c ccrtrtti.lib, and link with it. At the time of
 writing you can get it from here:
 @verbatim
 http://support.microsoft.com/kb/830482/en-us
 @endverbatim
 Otherwise you will get linker errors similar to this:
 @verbatim
 wxwince26d.lib(control.obj) : error LNK2001: unresolved external symbol "const type_info::`vftable'" (??_7type_info@@6B@)
 @endverbatim
 <b>Windows Mobile 5.0 emulator</b>
 Note that there is no separate emulator configuration for Windows Mobile 5.0: the
 emulator runs the ARM code directly.
 <b>Visual Studio 2005 project files</b>
 Unfortunately, Visual Studio 2005, required to build Windows Mobile 5.0 applications,
 doesn't do a perfect job of converting the project files from eVC++ format.
 When you have converted the wxWidgets workspace, edit the configuration properties
 for each configuration and in the Librarian, add a relative path ..\..\lib to
 each library path. For example: 
 <tt>..\$(PlatformName)\$(ConfigurationName)\wx_mono.lib</tt>.
 Then, for a sample you want to compile, edit the configuration properties
 and make sure 
 <tt>..\..\lib\\$(PlatformName)\\$(ConfigurationName)</tt> 
 is in the Linker/General/Additional Library Directories property. 
 Also change the Linker/Input/Additional Dependencies property to something like 
 <tt>coredll.lib wx_mono.lib wx_wxjpeg.lib wx_wxpng.lib wx_wxzlib.lib wx_wxexpat.lib 
     commctrl.lib winsock.lib wininet.lib</tt>
 (since the library names in the wxWidgets workspace were changed by VS 2005).
 Alternately, you could could edit all the names to be identical to the original eVC++
 names, but this will probably be more fiddly.
 @subsubsection port_ Remaining issues
 These are some of the remaining problems to be sorted out, and features
 to be supported.
 @li <b>Windows Mobile 5 issues.</b> It is not possible to get the HMENU for
 the command bar on Mobile 5, so the menubar functions need to be rewritten
 to get the individual menus without use of a menubar handle. Also the
 new Mobile 5 convention of using only two menus (and no bitmap buttons) needs to be
 considered.
 @li <b>Sizer speed.</b> Particularly for dialogs containing notebooks,
 layout seems slow. Some analysis is required.
 @li <b>Notification boxes.</b> The balloon-like notification messages, and their
 icons, should be implemented. This will be quite straightforward.
 @li <b>SIP size.</b> We need to be able to get the area taken up by the SIP (input panel),
 and the remaining area, by calling SHSipInfo. We also may need to be able to show and hide
 the SIP programmatically, with SHSipPreference. See also the <em>Input Dialogs</em> topic in
 the <em>Programming Windows CE</em> guide for more on this, and how to have dialogs
 show the SIP automatically using the WC_SIPREF control.
 @li <b>wxStaticBitmap.</b> The About box in the "Life!" demo shows a bitmap that is
 the correct size on the emulator, but too small on a VGA Pocket Loox device.
 @li <b>wxStaticLine.</b> Lines don't show up, and the documentation suggests that
 missing styles are implemented with WM_PAINT.
 @li <b>HTML control.</b> PocketPC has its own HTML control which can be used for showing
 local pages or navigating the web. We should create a version of wxHtmlWindow that uses this
 control, or have a separately-named control (wxHtmlCtrl), with a syntax as close as possible 
 to wxHtmlWindow.
 @li <b>Tooltip control.</b> PocketPC uses special TTBUTTON and TTSTATIC controls for adding
 tooltips, with the tooltip separated from the label with a double tilde. We need to support 
 this using SetToolTip.(Unfortunately it does not seem possible to dynamically remove the tooltip, 
 so an extra style may be required.)
 @li <b>Focus.</b> In the wxPropertySheetDialog demo on Smartphone, it's not possible to navigate
 between controls. The focus handling in wxWidgets needs investigation. See in particular 
 src/common/containr.cpp, and note that the default OnActivate handler in src/msw/toplevel.cpp 
 sets the focus to the first child of the dialog.
 @li <b>OK button.</b> We should allow the OK button on a dialog to be optional, perhaps
 by using wxCLOSE_BOX to indicate when the OK button should be displayed.
 @li <b>Dynamic adaptation.</b> We should probably be using run-time tests more
 than preprocessor tests, so that the same WinCE application can run on different
 versions of the operating system.
 @li <b>Modeless dialogs.</b> When a modeless dialog is hidden with the OK button, it doesn't restore the
 frame's menubar. See for example the find dialog in the dialogs sample. However, the menubar is restored
 if pressing Cancel (the window is closed). This reflects the fact that modeless dialogs are
 not very useful on Windows CE; however, we could perhaps destroy/restore a modeless dialog's menubar
 on deactivation and activation.
 @li <b>Home screen plugins.</b> Figure out how to make home screen plugins for use with wxWidgets
 applications (see http://www.codeproject.com/ce/CTodayWindow.asp for inspiration).
 Although we can't use wxWidgets to create the plugin (too large), we could perhaps write
 a generic plugin that takes registry information from a given application, with
 options to display information in a particular way using icons and text from
 a specified location.
 @li <b>Further abstraction.</b> We should be able to abstract away more of the differences
 between desktop and mobile applications, in particular for sizer layout.
 @li <b>Dialog captions.</b> The blue, bold captions on dialogs - with optional help button -
 should be catered for, either by hard-wiring the capability into all dialogs and panels,
 or by providing a standard component and sizer.
 @section nativedocs Documentation for the native toolkits