AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

removed almost all TeX code from main manual pages

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@51913 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Francesco Montorsi 2008-02-19 15:15:32 +00:00
parent 3d902bdfa8
commit 25c4a27cb3
14 changed files with 1730 additions and 327 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
docs/doxygen/categories.h
View File

@ -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ç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 wxMDIDocParentFrame: An MDI parent frame to contain views
<!-- %@li wxMDIDocChildFrame: An MDI child frame for showing a document view
%@li wxMDIDocParentFrame: An MDI parent frame to contain views -->
@section cat_printing Printing framework

231
docs/doxygen/const_cpp.h Normal file
View File

@ -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}
*/

156
docs/doxygen/const_keycode.h Normal file
View File

@ -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
*/

42
docs/doxygen/const_keymod.h Normal file
View File

@ -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.
*/

24
docs/doxygen/const_langcodes.h Normal file
View File

@ -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 -->
*/

150
docs/doxygen/const_stdevtid.h Normal file
View File

@ -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
*/

78
docs/doxygen/const_stockitems.h Normal file
View File

@ -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.
*/

342
docs/doxygen/const_wxusedef.h Normal file
View File

@ -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}
*/

15
docs/doxygen/constants.h
View File

@ -11,13 +11,14 @@
@page constants_page Constants
This chapter describes the constants defined by wxWidgets.
@li @ref cppconst
<hr>
@section cppconst Preprocessor symbols defined by wxWidgets
@li @ref keycodes
@li @ref keymodifiers
@li @ref languagecodes
@li @ref stdevtid
@li @ref stockitems
@li @ref wxusedef
*/

10
docs/doxygen/copyright.h
View File

@ -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.

205
docs/doxygen/devtips.h
View File

@ -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
information on these.
See the @ref librarieslist for more 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
so programs that search your executable for icons (such
as the Program Manager) find your application icon first.}
@note include wx.rc @e after any ICON statements
so programs that search your executable for icons (such
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}
symbols listed in the file {\tt setup.h} may be used for this purpose,
features (such as metafile use under MS Windows). The @ref wxusedef
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
@verbatim
@code
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},
\helpref{wxTextOutputStream}{wxtextoutputstream} classes help to abstract
The wxTextFile, wxTextInputStream, 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.
*/

149
docs/doxygen/introduction.h
View File

@ -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
\item low price;
\item source availability;
\item simplicity of programming;
\item support for a wide range of compilers.
\end{enumerate}
@li low price;
@li source availability;
@li simplicity of programming;
@li support for a wide range of compilers.
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
\item Low cost (free, in fact!)
\item You get the source.
\item Available on a variety of popular platforms.
\item Works with almost all popular C++ compilers and Python.
\item Over 70 example programs.
\item Over 1000 pages of printable and on-line documentation.
\item Simple-to-use, object-oriented API.
\item Flexible event system.
\item Graphics calls include lines, rounded rectangles, splines, polylines, etc.
\item Constraint-based and sizer-based layouts.
\item Print/preview and document/view architectures.
\item Toolbar, notebook, tree control, advanced list control classes.
\item PostScript generation under Unix, normal MS Windows printing on the PC.
\item MDI (Multiple Document Interface) support.
\item Can be used to create DLLs under Windows, dynamic libraries on Unix.
\item Common dialogs for file browsing, printing, colour selection, etc.
\item Under MS Windows, support for creating metafiles and copying
them to the clipboard.
\item An API for invoking help from applications.
\item Ready-to-use HTML window (supporting a subset of HTML).
\item Network support via a family of socket and protocol classes.
\item Support for platform independent image processing.
\item Built-in support for many file formats (BMP, PNG, JPEG, GIF, XPM, PNM, PCX).
\item Includes Tex2RTF, to allow you to produce your own documentation
in Windows Help, HTML and Word RTF formats.
\end{itemize}
@li Low cost (free, in fact!)
@li You get the source.
@li Available on a variety of popular platforms.
@li Works with almost all popular C++ compilers and Python.
@li Over 70 example programs.
@li Over 1000 pages of printable and on-line documentation.
@li Simple-to-use, object-oriented API.
@li Flexible event system.
@li Graphics calls include lines, rounded rectangles, splines, polylines, etc.
@li Constraint-based and sizer-based layouts.
@li Print/preview and document/view architectures.
@li Toolbar, notebook, tree control, advanced list control classes.
@li PostScript generation under Unix, normal MS Windows printing on the PC.
@li MDI (Multiple Document Interface) support.
@li Can be used to create DLLs under Windows, dynamic libraries on Unix.
@li Common dialogs for file browsing, printing, colour selection, etc.
@li Under MS Windows, support for creating metafiles and copying them to the clipboard.
@li An API for invoking help from applications.
@li Ready-to-use HTML window (supporting a subset of HTML).
@li Network support via a family of socket and protocol classes.
@li Support for platform independent image processing.
@li Built-in support for many file formats (BMP, PNG, JPEG, GIF, XPM, PNM, PCX).
@li Includes Tex2RTF, to allow you to produce your own documentation
in Windows Help, HTML and Word RTF formats.
@section requirements wxWidgets requirements
@ -128,69 +126,62 @@
(a) MS-Windows:
\begin{enumerate}\itemsep=0pt
\item A 32-bit or 64-bit PC running MS Windows.
\item A Windows compiler: MS Visual C++ (embedded Visual C++ for wxWinCE
port), Borland C++, Watcom C++, Cygwin, MinGW, Metrowerks CodeWarrior,
Digital Mars C++. See {\tt install.txt} for details about compiler
version supported.
\end{enumerate}
@li A 32-bit or 64-bit PC running MS Windows.
@li A Windows compiler: MS Visual C++ (embedded Visual C++ for wxWinCE
port), Borland C++, Watcom C++, Cygwin, MinGW, Metrowerks CodeWarrior,
Digital Mars C++. See @c install.txt for details about compiler
version supported.
(b) Unix:
\begin{enumerate}\itemsep=0pt
\item Almost any C++ compiler, including GNU C++ and many Unix vendors
compilers such as Sun CC, HP-UX aCC or SGI mipsPro.
\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
many features of wxGTK2), Motif 1.2 or higher or Lesstif. If using the wxX11
port, no such widget set is required.
\end{enumerate}
@li Almost any C++ compiler, including GNU C++ and many Unix vendors
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
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
port, no such widget set is required.
(c) Mac OS/Mac OS X:
\begin{enumerate}\itemsep=0pt
\item A PowerPC or Intel Mac running Mac OS X 10.3 or higher
\item The Apple Developer Tools (eg. GNU C++) or MetroWerks CodeWarrior (not
actively supported)
\end{enumerate}
@li 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
actively supported)
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
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}.}
wxWidgets is available by anonymous FTP and World Wide Web
from ftp://biolpc22.york.ac.uk/pub and/or 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
\item Julian Smart
\item Vadim Zeitlin
\item Robert Roebling
\item Robin Dunn
\item Stefan Csomor
\item Vaclav Slavik
\item Paul Cornett
\item Wlodzimierz `ABX' Skiba
\item Chris Elliott
\item David Elliott
\item Kevin Hock
\item Stefan Neis
\item Michael Wetherell
\end{description}
@li Julian Smart
@li Vadim Zeitlin
@li Robert Roebling
@li Robin Dunn
@li Stefan Csomor
@li Vaclav Slavik
@li Paul Cornett
@li Wlodzimierz `ABX' Skiba
@li Chris Elliott
@li David Elliott
@li Kevin Hock
@li Stefan Neis
@li Michael Wetherell
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>
*/

87
docs/doxygen/libs.h
View File

@ -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
libraries ({\it multilib build}). Multilib build is the default.
library (this is called the <em>monolithic build</em>) or as several smaller
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 green boxes depend from wxCore library (i.e. they are GUI libraries).
all blue boxes depend from wxBase library (i.e. they are non-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.
\helpref{wxString}{wxstring}) and portability classes that abstract
differences between platforms. wxBase can be used to develop console mode
applications, it does not require any GUI libraries or running X Window System
on Unix.
mandatory classes that any wxWidgets code depends on (e.g. wxString) and
portability classes that abstract differences between platforms.
wxBase can be used to develop console mode applications, it does not require
any GUI libraries or running X Window System 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}
\item{ wxSocket classes (\helpref{wxSocketClient}{wxsocketclient},
\helpref{wxSocketServer}{wxsocketserver} and related classes) }
\item{ \helpref{wxSocketOutputStream}{wxsocketoutputstream} and
\helpref{wxSocketInputStream}{wxsocketinputstream} }
\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}
@li wxSocket classes (wxSocketClient, wxSocketServer and related classes)
@li wxSocketOutputStream and wxSocketInputStream
@li sockets-based IPC classes (wxTCPServer, wxTCPClient and wxTCPConnection)
@li wxURL
@li wxInternetFSHandler (a wxFileSystem handler)
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
\item{ \helpref{wxCalendarCtrl}{wxcalendarctrl} }
\item{ \helpref{wxGrid classes}{gridoverview} }
\item{ \helpref{wxJoystick}{wxjoystick} }
\item{ \helpref{wxLayoutAlgorithm}{wxlayoutalgorithm} }
\item{ \helpref{wxSplashScreen}{wxsplashscreen} }
\item{ \helpref{wxTaskBarIcon}{wxtaskbaricon} }
\item{ \helpref{wxSound}{wxsound} }
\item{ \helpref{wxWizard}{wxwizard} }
\item{ \helpref{wxSashLayoutWindow}{wxsashlayoutwindow} }
\item{ \helpref{wxSashWindow}{wxsashwindow} }
\item{ ...others }
\end{itemize}
@li wxCalendarCtrl
@li wxGrid classes
@li wxJoystick
@li wxLayoutAlgorithm
@li wxSplashScreen
@li wxTaskBarIcon
@li wxSound
@li wxWizard
@li wxSashLayoutWindow
@li wxSashWindow
@li ...others
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
contained in this library, as well as
\helpref{wxHtmlHelpController}{wxhtmlhelpcontroller},
\helpref{wxBestHelpController}{wxhelpcontroller} and
\helpref{wxHtmlListBox}{wxhtmllistbox}.
Simple HTML renderer and other @ref html_overview are contained in this library,
as well as wxHtmlHelpController, wxBestHelpController and 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.

562
docs/doxygen/platdetails.h
View File

@ -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
\input wxpalm.tex
\input wxos2.tex
\input wxmgl.tex
\input wxx11.tex
@section wxgtkport wxGTK port
wxGTK is a port of wxWidgets using the GTK+ library.
It makes use of GTK+'s native widgets wherever possible and uses
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