cheng/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

move pages under 'mainpages' and also adopt new link anchor naming and use @itemdef instead of \twocolitem tag

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@51975 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Francesco Montorsi 2008-02-21 21:11:25 +00:00
parent 94883ba1f4
commit 4514447c97
20 changed files with 4631 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
docs/doxygen/Doxyfile
View File

@ -1,7 +1,7 @@
#############################################################################
## Name: Doxyfile
## Purpose: Doxygen configuration file for wxWidgets manual
## Author: wxWidgets team
## Author: Francesco Montorsi
## RCS-ID: $Id$
## Licence: wxWindows license
#############################################################################
@ -62,7 +62,7 @@ ALIASES += beginExtraStyleTable="\section class_extrastyles Extra Styles\n"
ALIASES += endExtraStyleTable="\n"
# misc aliases
ALIASES += library{1}="\section class_lib Library\n \ref \1"
ALIASES += library{1}="\section class_lib Library\n \ref page_libraries_\1"
ALIASES += nolibrary="\section class_lib Library\n None; this class implementation is entirely header-based."
ALIASES += stdobjects="\section class_stdobj Predefined objects\n \b"
@ -82,14 +82,47 @@ ALIASES += true="<b><tt>true</tt></b>"
ALIASES += false="<b><tt>false</tt></b>"
ALIASES += NULL="<b><tt>NULL</tt></b>"
# these are useful for creation of tables
# table aliases for 2 and 3 column tables
ALIASES += beginTable="<center><table class='doctable'>"
ALIASES += beginInvisibleTable="<center><table class='doctable' border='0'>"
ALIASES += row{2}="<tr><td>\1</td> <td>\2</td></tr>"
ALIASES += row{3}="<tr><td>\1</td> <td>\2 \3</td></tr>"
ALIASES += row{4}="<tr><td>\1</td> <td>\2 \3 \4</td></tr>"
ALIASES += row2col{2}="<tr><td>\1</td> <td>\2</td></tr>"
ALIASES += row2col{3}="<tr><td>\1</td> <td>\2,\3</td></tr>"
ALIASES += row2col{4}="<tr><td>\1</td> <td>\2,\3,\4</td></tr>"
ALIASES += row2col{5}="<tr><td>\1</td> <td>\2,\3,\4,\5</td></tr>"
ALIASES += row2col{6}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6</td></tr>"
ALIASES += row2col{7}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6,\7</td></tr>"
ALIASES += row2col{8}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6,\7,\8</td></tr>"
ALIASES += row2col{9}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6,\7,\8,\9</td></tr>"
ALIASES += row2col{10}="<tr><td>\1</td> <td>\2,\3,\4,\5,\6,\7,\8,\9,\10</td></tr>"
ALIASES += row3col{3}="<tr><td>\1</td> <td>\2</td> <td>\3</td></tr>"
ALIASES += row3col{4}="<tr><td>\1</td> <td>\2</td> <td>\3,\4</td></tr>"
ALIASES += row3col{5}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5</td></tr>"
ALIASES += row3col{6}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6</td></tr>"
ALIASES += row3col{7}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7</td></tr>"
ALIASES += row3col{8}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8</td></tr>"
ALIASES += row3col{9}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9</td></tr>"
ALIASES += row3col{10}="<tr><td>\1</td> <td>\2</td> <td>\3,\4,\5,\6,\7,\8,\9,\10</td></tr>"
ALIASES += endTable="</table></center>"
# definition list aliases
# a definition list currently is rendered as 2-column table but it may use as
# well the <dl>, <dt> and <dd> HTML tags in future.
# In any case a definition list differs from a table because of its semantic
# nature and because it is always the association of a "title" with a "description"
# (in contrast a table may have more than 2 columns of data)...
ALIASES += beginDefList="<table class='doclist'>"
ALIASES += itemdef{2}="<tr><td>\b \1</td> <td>\2</td></tr>"
ALIASES += itemdef{3}="<tr><td>\b \1</td> <td>\2,\3</td></tr>"
ALIASES += itemdef{4}="<tr><td>\b \1</td> <td>\2,\3,\4</td></tr>"
ALIASES += itemdef{5}="<tr><td>\b \1</td> <td>\2,\3,\4,\5</td></tr>"
ALIASES += itemdef{6}="<tr><td>\b \1</td> <td>\2,\3,\4,\5,\6</td></tr>"
ALIASES += itemdef{7}="<tr><td>\b \1</td> <td>\2,\3,\4,\5,\6,\7</td></tr>"
ALIASES += itemdef{8}="<tr><td>\b \1</td> <td>\2,\3,\4,\5,\6,\7,\8</td></tr>"
ALIASES += itemdef{9}="<tr><td>\b \1</td> <td>\2,\3,\4,\5,\6,\7,\8,\9</td></tr>"
ALIASES += itemdef{10}="<tr><td>\b \1</td> <td>\2,\3,\4,\5,\6,\7,\8,\9,\10</td></tr>"
ALIASES += endDefList="</table>"
# NOTE: we could put aliases also for e.g. @wxDefaultSize, @wxDefaultPosition, @wxID_ANY,
# @wxEmptyString, @wxNullIcon, etc etc
@ -147,7 +180,7 @@ WARN_LOGFILE = doxygen.log
#---------------------------------------------------------------------------
# configuration options related to the input files
#---------------------------------------------------------------------------
INPUT = . ./overviews ../../interface
INPUT = ./mainpages ./overviews #../../interface
INPUT_ENCODING = UTF-8
FILE_PATTERNS = *.h *.txt
RECURSIVE = YES

740
docs/doxygen/mainpages/categories.h Normal file
View File

@ -0,0 +1,740 @@
/////////////////////////////////////////////////////////////////////////////
// Name: categories.h
// Purpose: Classes-by-category page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_categories Classes by category
A classification of wxWidgets classes by category.
@beginInvisibleTable
<tr><td>
@li @ref page_categories_manwnd
@li @ref page_categories_miscwnd
@li @ref page_categories_cmndlg
@li @ref page_categories_ctrl
@li @ref page_categories_miscpickers
@li @ref page_categories_menus
@li @ref page_categories_wxaui
@li @ref page_categories_winlayout
@li @ref page_categories_dc
@li @ref page_categories_gdi
@li @ref page_categories_events
@li @ref page_categories_val
@li @ref page_categories_data
@li @ref page_categories_containers
@li @ref page_categories_smartpointers
@li @ref page_categories_rtti
@li @ref page_categories_logging
@li @ref page_categories_debugging
@li @ref page_categories_net
</td><td>
@li @ref page_categories_ipc
@li @ref page_categories_dvf
@li @ref page_categories_printing
@li @ref page_categories_dd
@li @ref page_categories_file
@li @ref page_categories_streams
@li @ref page_categories_threading
@li @ref page_categories_html
@li @ref page_categories_rich
@li @ref page_categories_stc
@li @ref page_categories_vfs
@li @ref page_categories_xml
@li @ref page_categories_xrc
@li @ref page_categories_help
@li @ref page_categories_media
@li @ref page_categories_gl
@li @ref page_categories_appmanagement
@li @ref page_categories_misc
</td></tr>
@endTable
<hr>
@section page_categories_manwnd Managed windows
There are several types of window that are directly controlled by the
window manager (such as MS Windows, or the Motif Window Manager).
Frames and dialogs are similar in wxWidgets, but only dialogs may be modal.
@li wxTopLevelWindow: Any top level window, dialog or frame
@li wxDialog: Dialog box
@li wxFrame: Normal frame
@li wxMDIChildFrame: MDI child frame
@li wxMDIParentFrame: MDI parent frame
@li wxMiniFrame: A frame with a small title bar
@li wxPropertySheetDialog: Property sheet dialog
@li wxSplashScreen: Splash screen class
@li wxTipWindow: Shows text in a small window
@li wxWizard: A wizard dialog
See also the @ref commondialogs_overview.
@section page_categories_miscwnd Miscellaneous windows
The following are a variety of classes that are derived from wxWindow.
@li wxPanel: A window whose colour changes according to current user settings
@li wxScrolledWindow: Window with automatically managed scrollbars
@li wxGrid: A grid (table) window
@li wxSplitterWindow: Window which can be split vertically or horizontally
@li wxStatusBar: Implements the status bar on a frame
@li wxToolBar: Toolbar class
@li wxNotebook: Notebook class
@li wxListbook: Similar to notebook but using list control
@li wxChoicebook: Similar to notebook but using choice control
@li wxTreebook: Similar to notebook but using tree control
@li wxSashWindow: Window with four optional sashes that can be dragged
@li wxSashLayoutWindow: Window that can be involved in an IDE-like layout arrangement
@li wxVScrolledWindow: As wxScrolledWindow but supports lines of variable height
@li wxWizardPage: A base class for the page in wizard dialog.
@li wxWizardPageSimple: A page in wizard dialog.
@section page_categories_cmndlg Common dialogs
@ref commondialogs_overview
Common dialogs are ready-made dialog classes which are frequently used
in an application.
@li wxDialog: Base class for common dialogs
@li wxColourDialog: Colour chooser dialog
@li wxDirDialog: Directory selector dialog
@li wxFileDialog: File selector dialog
@li wxFindReplaceDialog: Text search/replace dialog
@li wxMultiChoiceDialog: Dialog to get one or more selections from a list
@li wxSingleChoiceDialog: Dialog to get a single selection from a list and return the string
@li wxTextEntryDialog: Dialog to get a single line of text from the user
@li wxPasswordEntryDialog: Dialog to get a password from the user
@li wxFontDialog: Font chooser dialog
@li wxPageSetupDialog: Standard page setup dialog
@li wxPrintDialog: Standard print dialog
@li wxProgressDialog: Progress indication dialog
@li wxMessageDialog: Simple message box dialog
@li wxSymbolPickerDialog: Symbol selector dialog
@li wxRichTextFormattingDialog: A dialog for formatting the content of a wxRichTextCtrl
@li wxWizard: A wizard dialog.
@section page_categories_ctrl Controls
Typically, these are small windows which provide interaction with the user. Controls
that are not static can have wxValidator associated with them.
@li wxAnimationCtrl: A control to display an animation
@li wxControl: The base class for controls
@li wxButton: Push button control, displaying text
@li wxBitmapButton: Push button control, displaying a bitmap
@li wxBitmapComboBox: A combobox with bitmaps next to text items
@li wxToggleButton: A button which stays pressed when clicked by user.
@li wxBitmapToggleButton: A toggle button with bitmaps.
@li wxCalendarCtrl: Control showing an entire calendar month
@li wxCheckBox: Checkbox control
@li wxCheckListBox: A listbox with a checkbox to the left of each item
@li wxChoice: Choice control (a combobox without the editable area)
@li wxCollapsiblePane: A panel which can be shown/hidden by the user
@li wxComboBox: A choice with an editable area
@li wxComboCtrl: A combobox with application defined popup
@li wxDataViewCtrl: A control to tabular or tree like data
@li wxDataViewTreeCtrl: A specialized wxDataViewCtrl with wxTreeCtrl-like API
@li wxGauge: A control to represent a varying quantity, such as time remaining
@li wxGenericDirCtrl: A control for displaying a directory tree
@li wxHtmlListBox: An abstract class for creating listboxes showing HTML content
@li wxSimpleHtmlListBox: A listbox showing HTML content
@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&ccedil;ade) for wxListCtrl in report mode
@li wxOwnerDrawnComboBox: A combobox with owner-drawn list items
@li wxRichTextCtrl: Generic rich text editing control
@li wxTextCtrl: Single or multiline text editing control
@li wxTreeCtrl: Tree (hierarchy) control
@li wxScrollBar: Scrollbar control
@li wxSpinButton: A spin or `up-down' control
@li wxSpinCtrl: A spin control - i.e. spin button and text control
@li wxStaticText: One or more lines of non-editable text
@li wxHyperlinkCtrl: A static text which opens an URL when clicked
@li wxStaticBitmap: A control to display a bitmap
@li wxRadioBox: A group of radio buttons
@li wxRadioButton: A round button to be used with others in a mutually exclusive way
@li wxSlider: A slider that can be dragged by the user
@li wxVListBox: A listbox supporting variable height rows
@section page_categories_miscpickers Miscellaneous pickers
A picker control is a control whose appearance and behaviour is highly platform-dependent.
@li wxColourPickerCtrl: A control which allows the user to choose a colour
@li wxDirPickerCtrl: A control which allows the user to choose a directory
@li wxFilePickerCtrl: A control which allows the user to choose a file
@li wxFontPickerCtrl: A control which allows the user to choose a font
@li wxDatePickerCtrl: Small date picker control
@section page_categories_menus Menus
@li wxMenu: Displays a series of menu items for selection
@li wxMenuBar: Contains a series of menus for use with a frame
@li wxMenuItem: Represents a single menu item
@section page_categories_wxaui wxAUI - advanced user interface
This is a new set of classes for writing a customizable application
interface with built-in docking, floatable panes and a flexible
MDI-like interface. Further classes for custom notebooks with
draggable tabs etc. are in progress. See also @ref aui_overview.
@li wxAuiManager: The central class for managing the interface
@li wxAuiNotebook: A replacement notebook class with extra features
@li wxAuiPaneInfo: Describes a single pane
@li wxAuiDockArt: Art and metrics provider for customizing the docking user interface
@li wxAuiTabArt: Art and metrics provider for customizing the notebook user interface
@section page_categories_winlayout Window layout
There are two different systems for laying out windows (and dialogs in particular).
One is based upon so-called sizers and it requires less typing, thinking and calculating
and will in almost all cases produce dialogs looking equally well on all platforms, the
other is based on so-called constraints and is deprecated, though still available.
@ref sizer_overview describes sizer-based layout.
These are the classes relevant to sizer-based layout.
@li wxSizer: Abstract base class
@li wxGridSizer: A sizer for laying out windows in a grid with all fields having the same size
@li wxFlexGridSizer: A sizer for laying out windows in a flexible grid
@li wxGridBagSizer: Another grid sizer that lets you specify the cell an item is in, and items can span rows and/or columns.
@li wxBoxSizer: A sizer for laying out windows in a row or column
@li wxStaticBoxSizer: Same as wxBoxSizer, but with a surrounding static box
@li wxWrapSizer: A sizer which wraps its child controls as size permits
@ref constraints_overview describes constraints-based layout.
These are the classes relevant to constraints-based window layout.
@li wxIndividualLayoutConstraint: Represents a single constraint dimension
@li wxLayoutConstraints: Represents the constraints for a window class
Other layouting classes:
@li wxLayoutAlgorithm: An alternative window layout facility
@section page_categories_dc Device contexts
@ref dc_overview
Device contexts are surfaces that may be drawn on, and provide an
abstraction that allows parameterisation of your drawing code
by passing different device contexts.
@li wxAutoBufferedPaintDC: A helper device context for double buffered drawing inside @b OnPaint.
@li wxBufferedDC: A helper device context for double buffered drawing.
@li wxBufferedPaintDC: A helper device context for double buffered drawing inside @b OnPaint.
@li wxClientDC: A device context to access the client area outside @b OnPaint events
@li wxPaintDC: A device context to access the client area inside @b OnPaint events
@li wxWindowDC: A device context to access the non-client area
@li wxScreenDC: A device context to access the entire screen
@li wxDC: The device context base class
@li wxMemoryDC: A device context for drawing into bitmaps
@li wxMetafileDC: A device context for drawing into metafiles
@li wxMirrorDC: A proxy device context allowing for simple mirroring.
@li wxPostScriptDC: A device context for drawing into PostScript files
@li wxPrinterDC: A device context for drawing to printers
@section page_categories_gdi Graphics device interface
@ref bitmap_overview
These classes are related to drawing on device contexts and windows.
@li wxColour: Represents the red, blue and green elements of a colour
@li wxDCClipper: Wraps the operations of setting and destroying the clipping region
@li wxBitmap: Represents a bitmap
@li wxBrush: Used for filling areas on a device context
@li wxBrushList: The list of previously-created brushes
@li wxCursor: A small, transparent bitmap representing the cursor
@li wxFont: Represents fonts
@li wxFontList: The list of previously-created fonts
@li wxIcon: A small, transparent bitmap for assigning to frames and drawing on device contexts
@li wxImage: A platform-independent image class
@li wxImageList: A list of images, used with some controls
@li wxMask: Represents a mask to be used with a bitmap for transparent drawing
@li wxPen: Used for drawing lines on a device context
@li wxPenList: The list of previously-created pens
@li wxPalette: Represents a table of indices into RGB values
@li wxRegion: Represents a simple or complex region on a window or device context
@li wxRendererNative: Abstracts high-level drawing primitives
@section page_categories_events Events
@ref eventhandling_overview
An event object contains information about a specific event. Event handlers
(usually member functions) have a single, event argument.
@li wxActivateEvent: A window or application activation event
@li wxCalendarEvent: Used with wxCalendarCtrl
@li wxCalculateLayoutEvent: Used to calculate window layout
@li wxChildFocusEvent: A child window focus event
@li wxClipboardTextEvent: A clipboard copy/cut/paste treebook event event
@li wxCloseEvent: A close window or end session event
@li wxCommandEvent: An event from a variety of standard controls
@li wxContextMenuEvent: An event generated when the user issues a context menu command
@li wxDateEvent: Used with wxDatePickerCtrl
@li wxDialUpEvent: Event send by wxDialUpManager
@li wxDropFilesEvent: A drop files event
@li wxEraseEvent: An erase background event
@li wxEvent: The event base class
@li wxFindDialogEvent: Event sent by wxFindReplaceDialog
@li wxFocusEvent: A window focus event
@li wxKeyEvent: A keypress event
@li wxIconizeEvent: An iconize/restore event
@li wxIdleEvent: An idle event
@li wxInitDialogEvent: A dialog initialisation event
@li wxJoystickEvent: A joystick event
@li wxListEvent: A list control event
@li wxMaximizeEvent: A maximize event
@li wxMenuEvent: A menu event
@li wxMouseCaptureChangedEvent: A mouse capture changed event
@li wxMouseCaptureLostEvent: A mouse capture lost event
@li wxMouseEvent: A mouse event
@li wxMoveEvent: A move event
@li wxNavigationKeyEvent: An event set by navigation keys such as tab
@li wxNotebookEvent: A notebook control event
@li wxNotifyEvent: A notification event, which can be vetoed
@li wxPaintEvent: A paint event
@li wxProcessEvent: A process ending event
@li wxQueryLayoutInfoEvent: Used to query layout information
@li wxRichTextEvent: A rich text editing event
@li wxScrollEvent: A scroll event from sliders, stand-alone scrollbars and spin buttons
@li wxScrollWinEvent: A scroll event from scrolled windows
@li wxSizeEvent: A size event
@li wxSocketEvent: A socket event
@li wxSpinEvent: An event from wxSpinButton
@li wxSplitterEvent: An event from wxSplitterWindow
@li wxSysColourChangedEvent: A system colour change event
@li wxTimerEvent: A timer expiration event
@li wxTreebookEvent: A treebook control event
@li wxTreeEvent: A tree control event
@li wxUpdateUIEvent: A user interface update event
@li wxWindowCreateEvent: A window creation event
@li wxWindowDestroyEvent: A window destruction event
@li wxWizardEvent: A wizard event
@section page_categories_val Validators
@ref validator_overview
These are the window validators, used for filtering and validating
user input.
@li wxValidator: Base validator class
@li wxTextValidator: Text control validator class
@li wxGenericValidator: Generic control validator class
@section page_categories_data Data structures
These are the data structure classes supported by wxWidgets.
@li wxCmdLineParser: Command line parser class
@li wxDateSpan: A logical time interval.
@li wxDateTime: A class for date/time manipulations
@li wxLongLong: A portable 64 bit integer type
@li wxObject: The root class for most wxWidgets classes
@li wxPathList: A class to help search multiple paths
@li wxPoint: Representation of a point
@li wxRect: A class representing a rectangle
@li wxRegEx: Regular expression support
@li wxRegion: A class representing a region
@li wxString: A string class
@li wxStringTokenizer: A class for interpreting a string as a list of tokens or words
@li wxRealPoint: Representation of a point using floating point numbers
@li wxSize: Representation of a size
@li wxTimeSpan: A time interval.
@li wxURI: Represents a Uniform Resource Identifier
@li wxVariant: A class for storing arbitrary types that may change at run-time
@section page_categories_containers Container classes
@ref container_overview
These are classes, templates and class macros are used by wxWidgets. Most
of these classes provide a subset or almost complete STL API.
@li wxArray<T>: A type-safe dynamic array implementation (macro based)
@li wxArrayString: An efficient container for storing wxString objects
@li wxHashMap<T>: A type-safe hash map implementation (macro based)
@li wxHashSet<T>: A type-safe hash set implementation(macro based)
@li wxHashTable: A simple hash table implementation (deprecated, use wxHashMap)
@li wxList<T>: A type-safe linked list implementation (macro based)
@li wxVector<T>: Template base vector implementation identical to std::vector
@section page_categories_smartpointers Smart pointers
wxWidgets provides a few smart pointer class templates.
@li wxObjectDataPtr<T>: A shared pointer (using intrusive reference counting)
@li wxScopedPtr<T>: A scoped pointer
@li wxSharedPtr<T>: A shared pointer (using non-intrusive reference counting)
@li wxWeakRef<T>: A weak reference
@section page_categories_rtti Run-time class information system
@ref runtimeclass_overview
wxWidgets supports run-time manipulation of class information, and dynamic
creation of objects given class names.
@li wxClassInfo: Holds run-time class information
@li wxObject: Root class for classes with run-time information
@li RTTI macros: Macros for manipulating run-time information
@section page_categories_logging Logging features
@ref log_overview
wxWidgets provides several classes and functions for message logging.
Please see the @ref log_overview for more details.
@li wxLog: The base log class
@li wxLogStderr: Log messages to a C STDIO stream
@li wxLogStream: Log messages to a C++ iostream
@li wxLogTextCtrl: Log messages to a wxTextCtrl
@li wxLogWindow: Log messages to a log frame
@li wxLogGui: Default log target for GUI programs
@li wxLogNull: Temporarily suppress message logging
@li wxLogChain: Allows to chain two log targets
@li wxLogInterposer: Allows to filter the log messages
@li wxLogInterposerTemp: Allows to filter the log messages
@li wxStreamToTextRedirector: Allows to redirect output sent to @c cout to a wxTextCtrl
@li Log functions: Error and warning logging functions
@section page_categories_debugging Debugging features
@ref debugging_overview
wxWidgets supports some aspects of debugging an application through
classes, functions and macros.
@li wxDebugContext: Provides memory-checking facilities
@li Debugging macros: Debug macros for assertion and checking
@li WXDEBUG_NEW: Use this macro to give further debugging information
@li wxDebugReport: Base class for creating debug reports in case of a program crash.
@li wxDebugReportCompress: Class for creating compressed debug reports.
@li wxDebugReportUpload: Class for uploading compressed debug reports via HTTP.
@li wxDebugReportPreview: Abstract base class for previewing the contents of a debug report.
@li wxDebugReportPreviewStd: Standard implementation of wxDebugReportPreview.
@section page_categories_net Networking classes
wxWidgets provides its own classes for socket based networking.
@li wxDialUpManager: Provides functions to check the status of network connection and to establish one
@li wxIPV4address: Represents an Internet address
@li wxIPaddress: Represents an Internet address
@li wxSocketBase: Represents a socket base object
@li wxSocketClient: Represents a socket client
@li wxSocketServer: Represents a socket server
@li wxSocketEvent: A socket event
@li wxFTP: FTP protocol class
@li wxHTTP: HTTP protocol class
@li wxURL: Represents a Universal Resource Locator
@section page_categories_ipc Interprocess communication
@ref ipc_overview
wxWidgets provides simple interprocess communications facilities
based on Windows DDE, but available on most platforms using TCP.
@li wxClient, wxDDEClient: Represents a client
@li wxConnection, wxDDEConnection: Represents the connection between a client and a server
@li wxServer, wxDDEServer: Represents a server
@section page_categories_dvf Document-view framework
@ref docview_overview
wxWidgets supports a document/view framework which provides
housekeeping for a document-centric application.
@li wxDocument: Represents a document
@li wxView: Represents a view
@li wxDocTemplate: Manages the relationship between a document class and a view class
@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 -->
@section page_categories_printing Printing framework
@ref printing_overview
A printing and previewing framework is implemented to
make it relatively straightforward to provide document printing
facilities.
@li wxPreviewFrame: Frame for displaying a print preview
@li wxPreviewCanvas: Canvas for displaying a print preview
@li wxPreviewControlBar: Standard control bar for a print preview
@li wxPrintDialog: Standard print dialog
@li wxPageSetupDialog: Standard page setup dialog
@li wxPrinter: Class representing the printer
@li wxPrinterDC: Printer device context
@li wxPrintout: Class representing a particular printout
@li wxPrintPreview: Class representing a print preview
@li wxPrintData: Represents information about the document being printed
@li wxPrintDialogData: Represents information about the print dialog
@li wxPageSetupDialogData: Represents information about the page setup dialog
@section page_categories_dd Drag and drop and clipboard classes
@ref dnd_overview
@li wxDataObject: Data object class
@li wxDataFormat: Represents a data format
@li wxTextDataObject: Text data object class
@li wxFileDataObject: File data object class
@li wxBitmapDataObject: Bitmap data object class
@li wxURLDataObject: URL data object class
@li wxCustomDataObject: Custom data object class
@li wxClipboard: Clipboard class
@li wxDropTarget: Drop target class
@li wxFileDropTarget: File drop target class
@li wxTextDropTarget: Text drop target class
@li wxDropSource: Drop source class
@section page_categories_file File related classes
wxWidgets has several small classes to work with disk files, see wxfileoverview for more details.
@li wxFileName: Operations with the file name and attributes
@li wxDir: Class for enumerating files/subdirectories.
@li wxDirTraverser: Class used together with wxDir for recursively enumerating the files/subdirectories
@li wxFile: Low-level file input/output class.
@li wxFFile: Another low-level file input/output class.
@li wxTempFile: Class to safely replace an existing file
@li wxTextFile: Class for working with text files as with arrays of lines
@li wxStandardPaths: Paths for standard directories
@li wxPathList: A class to help search multiple paths
@section page_categories_streams Stream classes
wxWidgets has its own set of stream classes, as an alternative to often buggy standard stream
libraries, and to provide enhanced functionality.
@li wxStreamBase: Stream base class
@li wxStreamBuffer: Stream buffer class
@li wxInputStream: Input stream class
@li wxOutputStream: Output stream class
@li wxCountingOutputStream: Stream class for querying what size a stream would have.
@li wxFilterInputStream: Filtered input stream class
@li wxFilterOutputStream: Filtered output stream class
@li wxBufferedInputStream: Buffered input stream class
@li wxBufferedOutputStream: Buffered output stream class
@li wxMemoryInputStream: Memory input stream class
@li wxMemoryOutputStream: Memory output stream class
@li wxDataInputStream: Platform-independent binary data input stream class
@li wxDataOutputStream: Platform-independent binary data output stream class
@li wxTextInputStream: Platform-independent text data input stream class
@li wxTextOutputStream: Platform-independent text data output stream class
@li wxFileInputStream: File input stream class
@li wxFileOutputStream: File output stream class
@li wxFFileInputStream: Another file input stream class
@li wxFFileOutputStream: Another file output stream class
@li wxTempFileOutputStream: Stream to safely replace an existing file
@li wxStringInputStream: String input stream class
@li wxStringOutputStream: String output stream class
@li wxZlibInputStream: Zlib and gzip (compression) input stream class
@li wxZlibOutputStream: Zlib and gzip (compression) output stream class
@li wxZipInputStream: Input stream for reading from ZIP archives
@li wxZipOutputStream: Output stream for writing from ZIP archives
@li wxTarInputStream: Input stream for reading from tar archives
@li wxTarOutputStream: Output stream for writing from tar archives
@li wxSocketInputStream: Socket input stream class
@li wxSocketOutputStream: Socket output stream class
@section page_categories_threading Threading classes
@ref thread_overview
wxWidgets provides a set of classes to make use of the native thread
capabilities of the various platforms.
@li wxThread: Thread class
@li wxThreadHelper: Manages background threads easily
@li wxMutex: Mutex class
@li wxMutexLocker: Mutex locker utility class
@li wxCriticalSection: Critical section class
@li wxCriticalSectionLocker: Critical section locker utility class
@li wxCondition: Condition class
@li wxSemaphore: Semaphore class
@section page_categories_html HTML classes
wxWidgets provides a set of classes to display text in HTML format. These
class include a help system based on the HTML widget.
@li wxHtmlHelpController: HTML help controller class
@li wxHtmlWindow: HTML window class
@li wxHtmlEasyPrinting: Simple class for printing HTML
@li wxHtmlPrintout: Generic HTML wxPrintout class
@li wxHtmlParser: Generic HTML parser class
@li wxHtmlTagHandler: HTML tag handler, pluginable into wxHtmlParser
@li wxHtmlWinParser: HTML parser class for wxHtmlWindow
@li wxHtmlWinTagHandler: HTML tag handler, pluginable into wxHtmlWinParser
@section page_categories_rich Rich text classes
wxWidgets provides a set of generic classes to edit and print simple rich text with character
and paragraph formatting.
@li wxTextAttr: Attributes specifying text styling.
@li wxRichTextCtrl: A rich text control.
@li wxRichTextBuffer: The content of a rich text control.
@li wxRichTextCharacterStyleDefinition: Definition of character styling.
@li wxRichTextParagraphStyleDefinition: Definition of paragraph styling.
@li wxRichTextListStyleDefinition: Definition of list styling.
@li wxRichTextStyleSheet: A set of style definitions.
@li wxRichTextStyleComboCtrl: A drop-down control for applying styles.
@li wxRichTextStyleListBox: A listbox for applying styles.
@li wxRichTextStyleOrganiserDialog: A dialog that can be used for managing or browsing styles.
@li wxRichTextEvent: A rich text event.
@li wxRichTextRange: Specification for ranges in a rich text control or buffer.
@li wxRichTextFileHandler: File handler base class.
@li wxRichTextHTMLHandler: A handler for converting rich text to HTML.
@li wxRichTextXMLHandler: A handler for loading and saving rich text XML.
@li wxRichTextFormattingDialog: A dialog for rich text formatting.
@li wxRichTextPrinting: A class for easy printing of rich text buffers.
@li wxRichTextPrintout: A class used by wxRichTextPrinting.
@li wxRichTextHeaderFooterData: Header and footer data specification.
@section page_categories_stc Scintilla text editor classes
wxWidgets also provides a wrapper around the Scintilla text editor control, which is
a control for plain-text editing with support for highlighting, smart indentation, etc.
@li wxStyledTextCtrl: A wxWidgets implementation of the Scintilla source code editing component.
@section page_categories_vfs Virtual file system classes
wxWidgets provides a set of classes that implement an extensible virtual file system,
used internally by the HTML classes.
@li wxFSFile: Represents a file in the virtual file system
@li wxFileSystem: Main interface for the virtual file system
@li wxFileSystemHandler: Class used to announce file system type
@section page_categories_xml XML classes
@li wxXmlDocument: A class to parse XML files
@li wxXmlNode: A class which represents XML nodes
@li wxXmlAttribute: A class which represent an XML attribute
@section page_categories_xrc XML-based resource system classes
@ref xrc_overview
Resources allow your application to create controls and other user interface elements
from specifications stored in an XML format.
@li wxXmlResource: The main class for working with resources
@li wxXmlResourceHandler: The base class for XML resource handlers
@section page_categories_help Online help
@li wxHelpController: Family of classes for controlling help windows
@li wxHtmlHelpController: HTML help controller class
@li wxContextHelp: Class to put application into context-sensitive help mode
@li wxContextHelpButton: Button class for putting application into context-sensitive help mode
@li wxHelpProvider: Abstract class for context-sensitive help provision
@li wxSimpleHelpProvider: Class for simple context-sensitive help provision
@li wxHelpControllerHelpProvider: Class for context-sensitive help provision via a help controller
@li wxToolTip: Class implementing tooltips
@section page_categories_media Multimedia classes
@li wxMediaCtrl: Display multimedia contents.
@section page_categories_gl OpenGL classes
@li wxGLCanvas: Canvas that you can render OpenGL calls to.
@li wxGLContext: Class to ease sharing of OpenGL data resources.
@section page_categories_appmanagement Application and process-management classes
@li wxApp: Application class
@li wxCmdLineParser: Command line parser class
@li wxDllLoader: Class to work with shared libraries.
@li wxProcess: Process class
@section page_categories_misc Miscellaneous
@li wxCaret: A caret (cursor) object
@li wxConfigBase: Classes for reading/writing the configuration settings
@li wxTimer: Timer class
@li wxStopWatch: Stop watch class
@li wxMimeTypesManager: MIME-types manager class
@li wxSystemSettings: System settings class for obtaining various global parameters
@li wxSystemOptions: System options class for run-time configuration
@li wxAcceleratorTable: Accelerator table
@li wxAutomationObject: OLE automation class
@li wxFontMapper: Font mapping, finding suitable font for given encoding
@li wxEncodingConverter: Encoding conversions
@li wxCalendarDateAttr: Used with wxCalendarCtrl
@li wxQuantize: Class to perform quantization, or colour reduction
@li wxSingleInstanceChecker: Check that only single program instance is running
*/

249
docs/doxygen/mainpages/const_cpp.h Normal file
View File

@ -0,0 +1,249 @@
/////////////////////////////////////////////////////////////////////////////
// Name: const_cpp.h
// Purpose: Preprocessor symbols
// Author: Vadim Zeitlin
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page 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 @ifdef and not @if.
TODO: what can we use here instead of \twocolitem to keep text readable??
@li @ref page_cppconst_guisystem
@li @ref page_cppconst_os
@li @ref page_cppconst_cpu
@li @ref page_cppconst_hardware
@li @ref page_cppconst_compiler
@li @ref page_cppconst_featuretests
@li @ref page_cppconst_miscellaneous
<hr>
@section page_cppconst_guisystem GUI system
@beginDefList
@itemdef{__WINDOWS__, any Windows, you may also use __WXMSW__}
@itemdef{__WIN16__, Win16 API (not supported since wxWidgets 2.6)}
@itemdef{__WIN32__, Win32 API}
@itemdef{__WXBASE__, Only wxBase, no GUI features (same as @c wxUSE_GUI $== 0$)}
@itemdef{__WXCOCOA__, OS X using Cocoa API}
@itemdef{__WXDFB__, wxUniversal using DirectFB}
@itemdef{__WXWINCE__, Windows CE}
@itemdef{__WXGTK__, GTK+}
@itemdef{__WXGTK12__, GTK+ 1.2 or higher}
@itemdef{__WXGTK20__, GTK+ 2.0 or higher}
@itemdef{__WXGTK24__, GTK+ 2.4 or higher}
@itemdef{__WXGTK26__, GTK+ 2.6 or higher}
@itemdef{__WXGTK210__, GTK+ 2.10 or higher}
@itemdef{__WXMOTIF__, Motif}
@itemdef{__WXMOTIF20__, Motif 2.0 or higher}
@itemdef{__WXMAC__, Mac OS all targets}
@itemdef{__WXMAC_CLASSIC__, MacOS for Classic}
@itemdef{__WXMAC_CARBON__, MacOS for Carbon CFM (running under Classic or OSX)
or true OS X Mach-O Builds}
@itemdef{__WXMAC_OSX__, MacOS X Carbon Mach-O Builds}
@itemdef{__WXMGL__, SciTech Soft MGL (__WXUNIVERSAL__ will be also defined)}
@itemdef{__WXMSW__, Any Windows}
@itemdef{__WXOSX__, Any Mac OS X port (either Carbon or Cocoa)}
@itemdef{__WXPALMOS__, PalmOS}
@itemdef{__WXPM__, OS/2 native Presentation Manager}
@itemdef{__WXSTUBS__, Stubbed version ('template' wxWin implementation)}
@itemdef{__WXXT__, Xt; mutually exclusive with WX_MOTIF, not implemented in wxWidgets 2.x}
@itemdef{__WXX11__, wxX11 (__WXUNIVERSAL__ will be also defined)}
@itemdef{__WXWINE__, WINE (i.e. WIN32 on Unix)}
@itemdef{__WXUNIVERSAL__, wxUniversal port, always defined in addition
to one of the symbols above so this should be tested first.}
@itemdef{__X__, any X11-based GUI toolkit except GTK+}
@endDefList
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 page_cppconst_os Operating systems
@beginDefList
@itemdef{__APPLE__, any Mac OS version}
@itemdef{__AIX__, AIX}
@itemdef{__BSD__, Any *BSD system}
@itemdef{__CYGWIN__, Cygwin: Unix on Win32}
@itemdef{__DARWIN__, Mac OS X using the BSD Unix C library
(as opposed to using the Metrowerks MSL C/C++ library)}
@itemdef{__DATA_GENERAL__, DG-UX}
@itemdef{__DOS_GENERAL__, DOS (used with wxMGL only)}
@itemdef{__FREEBSD__, FreeBSD}
@itemdef{__HPUX__, HP-UX (Unix)}
@itemdef{__GNU__, GNU Hurd}
@itemdef{__LINUX__, Linux}
@itemdef{__MACH__, Mach-O Architecture (Mac OS X only builds)}
@itemdef{__OSF__, OSF/1}
@itemdef{__PALMOS__, PalmOS}
@itemdef{__SGI__, IRIX}
@itemdef{__SOLARIS__, Solaris}
@itemdef{__SUN__, Any Sun}
@itemdef{__SUNOS__, Sun OS}
@itemdef{__SVR4__, SystemV R4}
@itemdef{__SYSV__, SystemV generic}
@itemdef{__ULTRIX__, Ultrix}
@itemdef{__UNIX__, any Unix}
@itemdef{__UNIX_LIKE__, Unix, BeOS or VMS}
@itemdef{__VMS__, VMS}
@itemdef{__WINDOWS__, any Windows}
@itemdef{__WINE__, Wine}
@endDefList
@section page_cppconst_cpu Hardware architectures (CPU)
Note that not all of these symbols are always defined, it depends on the
compiler used.
@beginDefList
@itemdef{__ALPHA__, DEC Alpha architecture}
@itemdef{__INTEL__, Intel i386 or compatible}
@itemdef{__IA64__, Intel 64 bit architecture}
@itemdef{__POWERPC__, Motorola Power PC}
@endDefList
@section page_cppconst_hardware Hardware type
@beginDefList
@itemdef{__SMARTPHONE__, Generic mobile devices with phone buttons and a small display}
@itemdef{__PDA__, Personal digital assistant, usually with touch screen}
@itemdef{__HANDHELD__, Small but powerful computer, usually with a keyboard}
@itemdef{__POCKETPC__, Microsoft-powered PocketPC devices with touch-screen}
@itemdef{__WINCE_STANDARDSDK__, Microsoft-powered Windows CE devices, for generic Windows CE applications}
@itemdef{__WINCE_NET__, Microsoft-powered Windows CE .NET devices (_WIN32_WCE is 400 or greater)}
@itemdef{WIN32_PLATFORM_WFSP, Microsoft-powered smartphone}
@endDefList
@section page_cppconst_compiler Compilers
@beginDefList
@itemdef{__BORLANDC__, Borland C++. The value of the macro corresponds
to the compiler version: $500$ is $5.0$.}
@itemdef{__DJGPP__, DJGPP}
@itemdef{__DIGITALMARS__, Digital Mars}
@itemdef{__GNUG__, Gnu C++ on any platform, see also wxCHECK_GCC_VERSION}
@itemdef{__GNUWIN32__, Gnu-Win32 compiler, see also wxCHECK_W32API_VERSION}
@itemdef{__MINGW32__, MinGW}
@itemdef{__MWERKS__, CodeWarrior MetroWerks compiler}
@itemdef{__SUNCC__, Sun CC, see also wxCHECK_SUNCC_VERSION}
@itemdef{__SYMANTECC__, Symantec C++}
@itemdef{__VISAGECPP__, IBM Visual Age (OS/2)}
@itemdef{__VISUALC__, Microsoft Visual C++, see also wxCHECK_VISUALC_VERSION.
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 @ifdef __VISUALC7__ to test
for compiler version being precisely 7.}
@itemdef{__XLC__, AIX compiler}
@itemdef{__WATCOMC__, Watcom C++. The value of this macro corresponds to
the compiler version, $1100$ is $11.0$ and $1200$ is OpenWatcom.}
@itemdef{_WIN32_WCE, Windows CE version}
@endDefList
@section page_cppconst_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:
@beginDefList
@itemdef{wxHAS_LARGE_FILES, Defined if wxFile supports files more than 4GB in size.}
@itemdef{wxHAS_LARGE_FFILES, Defined if wxFFile supports files more than 4GB in size.}
@itemdef{wxHAS_POWER_EVENTS, Defined if wxPowerEvent are ever generated on the current platform.}
@itemdef{wxHAS_RADIO_MENU_ITEMS,
Defined if the current port supports radio menu items (see wxMenu::AppendRadioItem).}
@itemdef{wxHAS_RAW_KEY_CODES, Defined if raw key codes (see wxKeyEvent::GetRawKeyCode are supported.}
@itemdef{wxHAS_REGEX_ADVANCED, Defined if advanced syntax is available in wxRegEx.}
@itemdef{wxHAS_TASK_BAR_ICON, Defined if wxTaskBarIcon is available on the current platform.}
@endDefList
@section page_cppconst_miscellaneous Miscellaneous
@beginDefList
@itemdef{__WXWINDOWS__,
always defined in wxWidgets applications, see also wxCHECK_VERSION}
@itemdef{__WXDEBUG__, defined in debug mode, undefined in release mode}
@itemdef{wxUSE_XXX,
if defined as $1$, feature XXX is active, see the
@ref page_wxusedef (the symbols of this form are always defined,
use @if and not @ifdef to test for them)}
@itemdef{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 @ifndef WX_PRECOMP, individual
headers you need.}
@itemdef{_UNICODE and UNICODE, both are defined if wxUSE_UNICODE is set to $1$}
@itemdef{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.}
@itemdef{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)}
@itemdef{wxNO_RTTI, is defined if the compiler RTTI support has been switched off}
@itemdef{wxNO_EXCEPTIONS,
is defined if the compiler support for C++ exceptions has been switched off}
@itemdef{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.}
@itemdef{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}
@itemdef{WXUSINGDLL,
defined when compiling code which uses wxWidgets as a DLL/shared library}
@itemdef{WXBUILDING,
defined when building wxWidgets itself, whether as a static or shared library}
@endDefList
*/

154
docs/doxygen/mainpages/const_keycode.h Normal file
View File

@ -0,0 +1,154 @@
/////////////////////////////////////////////////////////////////////////////
// Name: platdetails.h
// Purpose: wxKeyCode values enumerated
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_keycodes Keycodes
@header{wx/defs.h}
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/mainpages/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 page_keymodifiers Key Modifiers
@header{wx/defs.h}
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/mainpages/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 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/mainpages/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 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/mainpages/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 page_stockitems Stock items
Window IDs for which stock buttons and menu items are created
(see the wxButton constructor and the wxMenuItem constructor):
@beginDefList
@itemdef{<b>Stock ID</b>, <b>Stock label</b>}
@itemdef{wxID_ABOUT, "&About"}
@itemdef{wxID_ADD, "Add" and}
@itemdef{wxID_APPLY, "&Apply"}
@itemdef{wxID_BOLD, "&Bold"}
@itemdef{wxID_CANCEL, "&Cancel"}
@itemdef{wxID_CLEAR, "&Clear"}
@itemdef{wxID_CLOSE, "&Close"}
@itemdef{wxID_COPY, "&Copy"}
@itemdef{wxID_CUT, "Cu&t"}
@itemdef{wxID_DELETE, "&Delete"}
@itemdef{wxID_EDIT, "&Edit"}
@itemdef{wxID_FIND, "&Find"}
@itemdef{wxID_FILE, "&File"}
@itemdef{wxID_REPLACE, "Find and rep&lace"}
@itemdef{wxID_BACKWARD, "&Back"}
@itemdef{wxID_DOWN, "&Down"}
@itemdef{wxID_FORWARD, "&Forward"}
@itemdef{wxID_UP, "&Up"}
@itemdef{wxID_HELP, "&Help"}
@itemdef{wxID_HOME, "&Home"}
@itemdef{wxID_INDENT, "Indent"}
@itemdef{wxID_INDEX, "&Index"}
@itemdef{wxID_ITALIC, "&Italic"}
@itemdef{wxID_JUSTIFY_CENTER, "Centered"}
@itemdef{wxID_JUSTIFY_FILL, "Justified"}
@itemdef{wxID_JUSTIFY_LEFT, "Align Left"}
@itemdef{wxID_JUSTIFY_RIGHT, "Align Right"}
@itemdef{wxID_NEW, "&New"}
@itemdef{wxID_NO, "&No"}
@itemdef{wxID_OK, "&OK"}
@itemdef{wxID_OPEN, "&Open"}
@itemdef{wxID_PASTE, "&Paste"}
@itemdef{wxID_PREFERENCES, "&Preferences"}
@itemdef{wxID_PRINT, "&Print"}
@itemdef{wxID_PREVIEW, "Print previe&w"}
@itemdef{wxID_PROPERTIES, "&Properties"}
@itemdef{wxID_EXIT, "&Quit"}
@itemdef{wxID_REDO, "&Redo"}
@itemdef{wxID_REFRESH, "Refresh"}
@itemdef{wxID_REMOVE, "Remove"}
@itemdef{wxID_REVERT_TO_SAVED, "Revert to Saved"}
@itemdef{wxID_SAVE, "&Save"}
@itemdef{wxID_SAVEAS, "Save &As..."}
@itemdef{wxID_SELECTALL, "Select all"}
@itemdef{wxID_STOP, "&Stop"}
@itemdef{wxID_UNDELETE, "Undelete"}
@itemdef{wxID_UNDERLINE, "&Underline"}
@itemdef{wxID_UNDO, "&Undo"}
@itemdef{wxID_UNINDENT, "&Unindent"}
@itemdef{wxID_YES, "&Yes"}
@itemdef{wxID_ZOOM_100, "&Actual Size"}
@itemdef{wxID_ZOOM_FIT, "Zoom to &Fit"}
@itemdef{wxID_ZOOM_IN, "Zoom &In"}
@itemdef{wxID_ZOOM_OUT, "Zoom &Out"}
@endDefList
Note that some of the IDs listed above have also a stock accelerator
and an help string associated.
*/

359
docs/doxygen/mainpages/const_wxusedef.h Normal file
View File

@ -0,0 +1,359 @@
/////////////////////////////////////////////////////////////////////////////
// Name: const_wxusedef.h
// Purpose: wxUSE preprocessor symbols
// Author: Tim Stahlhut
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page 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 @if and not @ifdef.
@li @ref page_wxusedef_multi
@li @ref page_wxusedef_unix
@li @ref page_wxusedef_x11
@li @ref page_wxusedef_gtk
@li @ref page_wxusedef_mac
@li @ref page_wxusedef_motif
@li @ref page_wxusedef_cocoa
@li @ref page_wxusedef_os2
@li @ref page_wxusedef_msw
@li @ref page_wxusedef_univ
<hr>
@section page_wxusedef_multi Generic wxUSE preprocessor symbols
@beginDefList
@itemdef{wxUSE_ABOUTDLG, Use wxAboutDialogInfo class.}
@itemdef{wxUSE_ACCEL, Use wxAcceleratorTable/Entry classes and support for them in wxMenu, wxMenuBar.}
@itemdef{wxUSE_AFM_FOR_POSTSCRIPT, In wxPostScriptDC class use AFM (adobe font metrics) file for character widths.}
@itemdef{wxUSE_ANIMATIONCTRL, Use wxAnimationCtrl class.}
@itemdef{wxUSE_APPLE_IEEE, IEEE Extended to/from double routines; see src/common/extended.c file.}
@itemdef{wxUSE_ARCHIVE_STREAMS, Enable streams for archive formats.}
@itemdef{wxUSE_AUI, Use AUI (dockable windows) library.}
@itemdef{wxUSE_BASE64, Enables Base64 support.}
@itemdef{wxUSE_BITMAPCOMBOBOX, Use wxBitmapComboBox class.}
@itemdef{wxUSE_BMPBUTTON, Use wxBitmapButton class.}
@itemdef{wxUSE_BUSYINFO, Use wxBusyInfo class.}
@itemdef{wxUSE_BUTTON, Use wxButton class.}
@itemdef{wxUSE_CALENDARCTRL, Use wxCalendarCtrl class.}
@itemdef{wxUSE_CARET, Use wxCaret class.}
@itemdef{wxUSE_CHECKBOX, Use wxCheckBox class.}
@itemdef{wxUSE_CHECKLISTBOX, Use wxCheckListBox class.}
@itemdef{wxUSE_CHOICE, Use wxChoice class.}
@itemdef{wxUSE_CHOICEBOOK, Use wxChoicebook class.}
@itemdef{wxUSE_CHOICEDLG, Use wxSingleChoiceDialog, or wxMultiChoiceDialog classes.}
@itemdef{wxUSE_CLIPBOARD, Use wxClipboard class.}
@itemdef{wxUSE_CMDLINE_PARSER, Use wxCmdLineParser class.}
@itemdef{wxUSE_COLLPANE, Use wxCollapsiblePane class.}
@itemdef{wxUSE_COLOURDLG, Use wxColourDialog class.}
@itemdef{wxUSE_COLOURPICKERCTRL, Use wxColourPickerCtrl class.}
@itemdef{wxUSE_COMBOBOX, Use wxComboBox class.}
@itemdef{wxUSE_COMBOCTRL, Use wxComboCtrl class.}
@itemdef{wxUSE_CONFIG, Use wxConfig and related classes.}
@itemdef{wxUSE_CONFIG_NATIVE, When enabled use native OS configuration instead of the wxFileConfig class.}
@itemdef{wxUSE_CONSOLE_EVENTLOOP, Enable event loop in console programs.}
@itemdef{wxUSE_CONSTRAINTS, Use wxLayoutConstraints}
@itemdef{wxUSE_CONTROLS, If set to $0$, no classes deriving from wxControl can be used.}
@itemdef{wxUSE_DATAOBJ, Use wxDataObject and related classes.}
@itemdef{wxUSE_DATAVIEWCTRL, Use wxDataViewCtrl class.}
@itemdef{wxUSE_DATEPICKCTRL, Use wxDatePickerCtrl class.}
@itemdef{wxUSE_DATETIME, Use wxDateTime and related classes.}
@itemdef{wxUSE_DBGHELP, Use wxDbgHelpDLL class.}
@itemdef{wxUSE_DEBUG_CONTEXT, Use wxDebugContext class.}
@itemdef{wxUSE_DEBUG_NEW_ALWAYS, See Debugging overview}
@itemdef{wxUSE_DEBUGREPORT, Use wxDebugReport class.}
@itemdef{wxUSE_DIALUP_MANAGER, Use wxDialUpManager and related classes.}
@itemdef{wxUSE_DIRDLG, Use wxDirDialog class.}
@itemdef{wxUSE_DIRPICKERCTRL, Use wxDirPickerCtrl class.}
@itemdef{wxUSE_DISPLAY, Use wxDisplay and related classes.}
@itemdef{wxUSE_DOC_VIEW_ARCHITECTURE, Use wxDocument and related classes.}
@itemdef{wxUSE_DRAG_AND_DROP, Use Drag and drop classes.}
@itemdef{wxUSE_DRAGIMAGE, Use wxDragImage class.}
@itemdef{wxUSE_DYNAMIC_LOADER, Use wxPluginManager and related classes. Requires wxDynamicLibrary}
@itemdef{wxUSE_DYNLIB_CLASS, Use wxDynamicLibrary}
@itemdef{wxUSE_EDITABLELISTBOX, Use wxEditableListBox class.}
@itemdef{wxUSE_EXCEPTIONS, Use exception handling.}
@itemdef{wxUSE_EXPAT, enable XML support using expat parser.}
@itemdef{wxUSE_EXTENDED_RTTI, Use extended RTTI, see also Runtime class information (RTTI)}
@itemdef{wxUSE_FFILE, Use wxFFile class.}
@itemdef{wxUSE_FILE, Use wxFile class.}
@itemdef{wxUSE_FILECONFIG, Use wxFileConfig class.}
@itemdef{wxUSE_FILECTRL, Use wxFileCtrl class.}
@itemdef{wxUSE_FILEDLG, Use wxFileDialog class.}
@itemdef{wxUSE_FILEPICKERCTRL, Use wxFilePickerCtrl class.}
@itemdef{wxUSE_FILESYSTEM, Use wxFileSystem and related classes.}
@itemdef{wxUSE_FINDREPLDLG, Use wxFindReplaceDialog class.}
@itemdef{wxUSE_FONTDLG, Use wxFontDialog class.}
@itemdef{wxUSE_FONTENUM, Use wxFontEnumerator class.}
@itemdef{wxUSE_FONTMAP, Use wxFontMapper class.}
@itemdef{wxUSE_FONTPICKERCTRL, Use wxFontPickerCtrl class.}
@itemdef{wxUSE_FS_ARCHIVE, Use virtual archive filesystems like wxArchiveFSHandler in wxFileSystem class.}
@itemdef{wxUSE_FS_INET, Use virtual HTTP/FTP filesystems like wxInternetFSHandler in wxFileSystem class.}
@itemdef{wxUSE_FS_ZIP, Please use wxUSE_FS_ARCHIVE instead.}
@itemdef{wxUSE_FSVOLUME, Use wxFSVolume class.}
@itemdef{wxUSE_GAUGE, Use wxGauge class.}
@itemdef{wxUSE_GENERIC_DRAGIMAGE, Used in wxDragImage sample.}
@itemdef{wxUSE_GENERIC_DRAWELLIPSE, See comment in wx/dc.h file.}
@itemdef{wxUSE_GEOMETRY, Use common geometry classes}
@itemdef{wxUSE_GIF, Use GIF wxImageHandler}
@itemdef{wxUSE_GLCANVAS, Enables OpenGL support.}
@itemdef{wxUSE_GLOBAL_MEMORY_OPERATORS, Override global operators @c new and @c delete to use wxWidgets memory leak detection}
@itemdef{wxUSE_GRAPHICS_CONTEXT, Use wxGraphicsContext and related classes.}
@itemdef{wxUSE_GRID, Use wxGrid and related classes.}
@itemdef{wxUSE_GUI, Use the GUI classes; if set to $0$ only non-GUI classes are available.}
@itemdef{wxUSE_HELP, Use wxHelpController and related classes.}
@itemdef{wxUSE_HTML, Use wxHtmlWindow and related classes.}
@itemdef{wxUSE_HYPERLINKCTRL, Use wxHyperlinkCtrl}
@itemdef{wxUSE_ICO_CUR, Support Windows ICO and CUR formats.}
@itemdef{wxUSE_IFF, Enables the wxImage handler for Amiga IFF images.}
@itemdef{wxUSE_IMAGE, Use wxImage and related classes.}
@itemdef{wxUSE_IMAGLIST, Use wxImageList class.}
@itemdef{wxUSE_INTL, Use wxLocale and related classes.}
@itemdef{wxUSE_IOSTREAMH, Use header "iostream.h" instead of "iostream".}
@itemdef{wxUSE_IPC, Use interprocess communication classes.}
@itemdef{wxUSE_IPV6, Use experimental wxIPV6address and related classes.}
@itemdef{wxUSE_JOYSTICK, Use wxJoystick class.}
@itemdef{wxUSE_LIBJPEG, Enables JPEG format support (requires libjpeg).}
@itemdef{wxUSE_LIBPNG, Enables PNG format support (requires libpng). Also requires wxUSE_ZLIB.}
@itemdef{wxUSE_LIBTIFF, Enables TIFF format support (requires libtiff).}
@itemdef{wxUSE_LISTBOOK, Use wxListbook class.}
@itemdef{wxUSE_LISTBOX, Use wxListBox class.}
@itemdef{wxUSE_LISTCTRL, Use wxListCtrl class.}
@itemdef{wxUSE_LOG, Use wxLog and related classes.}
@itemdef{wxUSE_LOG_DEBUG, Enabled when wxLog used with __WXDEBUG__ defined.}
@itemdef{wxUSE_LOG_DIALOG, Use wxLogDialog class.}
@itemdef{wxUSE_LOGGUI, Use wxLogGui class.}
@itemdef{wxUSE_LOGWINDOW, Use wxLogFrame class.}
@itemdef{wxUSE_LONGLONG, Use wxLongLong class.}
@itemdef{wxUSE_LONGLONG_NATIVE, Use native <tt>long long</tt> type in wxLongLong implementation.}
@itemdef{wxUSE_LONGLONG_WX, Use generic wxLongLong implementation.}
@itemdef{wxUSE_MDI, Use wxMDIParentFrame, and wxMDIChildFrame}
@itemdef{wxUSE_MDI_ARCHITECTURE, Use MDI-based document-view classes.}
@itemdef{wxUSE_MEDIACTRL, Use wxMediaCtrl.}
@itemdef{wxUSE_MEMORY_TRACING, Use wxWidgets memory leak detection, not recommended if using another memory debugging tool.}
@itemdef{wxUSE_MENUS, Use wxMenu and related classes.}
@itemdef{wxUSE_METAFILE, Use wxMetaFile and related classes.}
@itemdef{wxUSE_MIMETYPE, Use wxFileType class.}
@itemdef{wxUSE_MINIFRAME, Use wxMiniFrame class.}
@itemdef{wxUSE_MOUSEWHEEL, Support mouse wheel events.}
@itemdef{wxUSE_MSGDLG, Use wxMessageDialog class and wxMessageBox function.}
@itemdef{wxUSE_NATIVE_STATUSBAR, Use native wxStatusBar class.}
@itemdef{wxUSE_NOTEBOOK, Use wxNotebook and related classes.}
@itemdef{wxUSE_NUMBERDLG, Use wxNumberEntryDialog class.}
@itemdef{wxUSE_ODCOMBOBOX, Use wxOwnerDrawnComboBox class.}
@itemdef{wxUSE_ON_FATAL_EXCEPTION, Catch signals in wxApp::OnFatalException method.}
@itemdef{wxUSE_OPENGL, Please use wxUSE_GLCANVAS to test for enabled OpenGL support instead.}
@itemdef{wxUSE_OWNER_DRAWN, Use interface for owner-drawn GUI elements.}
@itemdef{wxUSE_PALETTE, Use wxPalette and related classes.}
@itemdef{wxUSE_PCX, Enables wxImage PCX handler.}
@itemdef{wxUSE_PNM, Enables wxImage PNM handler.}
@itemdef{wxUSE_POPUPWIN, Use wxPopupWindow class.}
@itemdef{wxUSE_POSTSCRIPT, Use wxPostScriptPrinter class.}
@itemdef{wxUSE_PRINTF_POS_PARAMS, Use wxVsnprintf which supports positional parameters.}
@itemdef{wxUSE_PRINTING_ARCHITECTURE, Enable printer classes.}
@itemdef{wxUSE_PROGRESSDLG, Enables progress dialog classes.}
@itemdef{wxUSE_PROTOCOL, Use wxProtocol and derived classes.}
@itemdef{wxUSE_PROTOCOL_FILE, Use wxFileProto class. (requires wxProtocol)}
@itemdef{wxUSE_PROTOCOL_FTP, Use wxFTP class. (requires wxProtocol)}
@itemdef{wxUSE_PROTOCOL_HTTP, Use wxHTTP class. (requireswxProtocol)}
@itemdef{wxUSE_RADIOBOX, Use wxRadioBox class.}
@itemdef{wxUSE_RADIOBTN, Use wxRadioButton class.}
@itemdef{wxUSE_REGEX, Use wxRegEx class.}
@itemdef{wxUSE_RICHTEXT, Use wxRichTextCtrl class.}
@itemdef{wxUSE_RICHTEXT_XML_HANDLER, See src/xrc/xh_richtext.cpp file.}
@itemdef{wxUSE_SASH, Use wxSashWindow class.}
@itemdef{wxUSE_SCROLLBAR, Use wxScrollBar class.}
@itemdef{wxUSE_SEARCHCTRL, Use wxSearchCtrl class.}
@itemdef{wxUSE_SELECT_DISPATCHER, Use wxSelectDispatcher class.}
@itemdef{wxUSE_SLIDER, Use wxSlider class.}
@itemdef{wxUSE_SNGLINST_CHECKER, Use wxSingleInstanceChecker class.}
@itemdef{wxUSE_SOCKETS, Enables Network address classes.}
@itemdef{wxUSE_SOUND, Use wxSound class.}
@itemdef{wxUSE_SPINBTN, Use wxSpinButton class.}
@itemdef{wxUSE_SPINCTRL, Use wxSpinCtrl class.}
@itemdef{wxUSE_SPLASH, Use wxSplashScreen class.}
@itemdef{wxUSE_SPLINES, Provide methods for spline drawing in wxDC.}
@itemdef{wxUSE_SPLITTER, Use wxSplitterWindow class.}
@itemdef{wxUSE_STACKWALKER, Enables wxStackWalker and related classes.}
@itemdef{wxUSE_STARTUP_TIPS, Use startup tips, wxTipProvider class.}
@itemdef{wxUSE_STATBMP, Use wxStaticBitmap class.}
@itemdef{wxUSE_STATBOX, Use wxStaticBox class.}
@itemdef{wxUSE_STATLINE, Use wxStaticLine class.}
@itemdef{wxUSE_STATTEXT, Use wxStaticText class.}
@itemdef{wxUSE_STATUSBAR, Use wxStatusBar class.}
@itemdef{wxUSE_STC, Use wxStyledTextCtrl.}
@itemdef{wxUSE_STD_IOSTREAM, Use standard C++ stream classes.}
@itemdef{wxUSE_STD_STRING, Use standard C++ string classes.}
@itemdef{wxUSE_STDPATHS, Use wxStandardPaths class.}
@itemdef{wxUSE_STL, Use Standard Template Library for the container classes and wxString implementation.}
@itemdef{wxUSE_STOPWATCH, Use wxStopWatch class.}
@itemdef{wxUSE_STREAMS, Enable stream classes.}
@itemdef{wxUSE_SVG, Use wxSVGFileDC class.}
@itemdef{wxUSE_SYSTEM_OPTIONS, Use wxSystemOptions class.}
@itemdef{wxUSE_TAB_DIALOG, Use the obsolete wxTabControl class.}
@itemdef{wxUSE_TARSTREAM, Enable Tar files support.}
@itemdef{wxUSE_TASKBARICON, Use wxTaskBarIcon class.}
@itemdef{wxUSE_TEXTBUFFER, Use wxTextBuffer class.}
@itemdef{wxUSE_TEXTCTRL, Use wxTextCtrl class.}
@itemdef{wxUSE_TEXTDLG, Use wxTextEntryDialog class.}
@itemdef{wxUSE_TEXTFILE, Use wxTextFile class.}
@itemdef{wxUSE_TGA, Enable wxImage TGA handler.}
@itemdef{wxUSE_THREADS, Use wxThread and related classes.}
@itemdef{wxUSE_TIMER, Use wxTimer class.}
@itemdef{wxUSE_TIPWINDOW, Use wxTipWindow class.}
@itemdef{wxUSE_TOGGLEBTN, Use wxToggleButton class.}
@itemdef{wxUSE_TOOLBAR, Use wxToolBar class.}
@itemdef{wxUSE_TOOLBAR_NATIVE, Use native wxToolBar class.}
@itemdef{wxUSE_TOOLBOOK, Use wxToolbook class.}
@itemdef{wxUSE_TOOLTIPS, Use wxToolTip class.}
@itemdef{wxUSE_TREEBOOK, Use wxTreebook class.}
@itemdef{wxUSE_TREECTRL, Use wxTreeCtrl class.}
@itemdef{wxUSE_TTM_WINDOWFROMPOINT, Obsolete, do not use.}
@itemdef{wxUSE_UNICODE, Compiled with Unicode support.}
@itemdef{wxUSE_UNICODE_UTF8, Compiled with UTF8 support.}
@itemdef{wxUSE_UNICODE_WCHAR, Compiled with Unicode support and using wchar_t type.}
@itemdef{wxUSE_URL, Use wxURL class.}
@itemdef{wxUSE_URL_NATIVE, Use native support for some operations with wxURL.}
@itemdef{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.}
@itemdef{wxUSE_VALIDATORS, Use wxValidator class.}
@itemdef{wxUSE_VARIANT, Use wxVariant class.}
@itemdef{wxUSE_WIZARDDLG, Use wxWizard class.}
@itemdef{wxUSE_WXHTML_HELP, Use wxHtmlHelpController and related classes.}
@itemdef{wxUSE_XML, Use XML parsing classes.}
@itemdef{wxUSE_XPM, Enable XPM reader for wxImage and wxBitmap classes.}
@itemdef{wxUSE_XRC, Use XRC XML-based resource system.}
@itemdef{wxUSE_ZIPSTREAM, Enable streams for Zip files.}
@itemdef{wxUSE_ZLIB, Use wxZlibInput and wxZlibOutputStream classes, required by wxUSE_LIBPNG.}
@endDefList
@section page_wxusedef_unix wxUSE preprocessor symbols used only under Unix platforms
@beginDefList
@itemdef{wxUSE_EPOLL_DISPATCHER, Use wxEpollDispatcher class. See also wxUSE_SELECT_DISPATCHER.}
@itemdef{wxUSE_GSTREAMER, Use GStreamer library in wxMediaCtrl.}
@itemdef{wxUSE_LIBMSPACK, Use libmspack library.}
@itemdef{wxUSE_LIBSDL, Use SDL for wxSound implementation.}
@itemdef{wxUSE_PLUGINS, See also wxUSE_LIBSDL.}
@itemdef{wxUSE_UNIX, Enabled on Unix Platform.}
@endDefList
@section page_wxusedef_x11 wxUSE preprocessor symbols used only in wxX11 Platform
@beginDefList
@itemdef{wxUSE_NANOX, Use NanoX.}
@itemdef{wxUSE_UNIV_TEXTCTRL, Use wxUniv's implementation of wxTextCtrl class.}
@endDefList
@section page_wxusedef_gtk wxUSE preprocessor symbols used only in wxGTK port
@beginDefList
@itemdef{wxUSE_DETECT_SM, Use code to detect X11 session manager.}
@itemdef{wxUSE_GTKPRINT, Use GTK+ printing support.}
@itemdef{wxUSE_LIBGNOMEPRINT, Use GNOME printing support.}
@itemdef{wxUSE_LIBGNOMEVFS, Use GNOME VFS support. Currently has no effect. }
@itemdef{wxUSE_LIBHILDON, Use Hildon framework for Nokia 770. Currently has no effect. }
@endDefList
@section page_wxusedef_mac wxUSE preprocessor symbols used only in wxMac port
@beginDefList
@itemdef{wxUSE_MAC_CRITICAL_REGION_MUTEX, See src/mac/carbon/thread.cpp file.}
@itemdef{wxUSE_MAC_PTHREADS_MUTEX, See src/mac/carbon/thread.cpp file.}
@itemdef{wxUSE_MAC_SEMAPHORE_MUTEX, See src/mac/carbon/thread.cpp file.}
@itemdef{wxUSE_WEBKIT, Use wxWebKitCtrl class.}
@endDefList
@section page_wxusedef_motif wxUSE preprocessor symbols used only in wxMotif port
@beginDefList
@itemdef{wxUSE_GADGETS, Use xmCascadeButtonGadgetClass, xmLabelGadgetClass, xmPushButtonGadgetClass and xmToggleButtonGadgetClass classes.}
@itemdef{wxUSE_INVISIBLE_RESIZE, See src/motif/dialog.cpp file.}
@endDefList
@section page_wxusedef_cocoa wxUSE preprocessor symbols used only in Cocoa port
@beginDefList
@itemdef{wxUSE_OBJC_UNIQUIFYING, Enable Objective-C class name uniquifying.}
@endDefList
@section page_wxusedef_os2 wxUSE preprocessor symbols used only in OS2 port
@beginDefList
@itemdef{wxUSE_CONSOLEDEBUG, See src/os2/app.cpp file.}
@itemdef{wxUSE_DDE, See src/os2/mimetype.cpp file.}
@itemdef{wxUSE_IMAGE_LOADING_IN_MSW, See src/os2/clipbrd.cpp file.}
@itemdef{wxUSE_IMAGE_LOADING_IN_OS2, See src/os2/gdiimage.cpp file.}
@itemdef{wxUSE_NET_API, Use NetBios32GetInfo API call.}
@itemdef{wxUSE_RESOURCE_LOADING_IN_OS2, See src/os2/gdiimage.cpp file.}
@endDefList
@section page_wxusedef_msw wxUSE preprocessor symbols used only in wxMSW port
@beginDefList
@itemdef{wxUSE_ACCESSIBILITY, Enable accessibility support}
@itemdef{wxUSE_ACTIVEX, Use wxActiveXContainer and related classes.}
@itemdef{wxUSE_COMBOCTRL_POPUP_ANIMATION, See wx/msw/combo.h file.}
@itemdef{wxUSE_COMCTL32_SAFELY, See src/msw/treectrl.cpp file.}
@itemdef{wxUSE_COMMON_DIALOGS, Enable use of windows common dialogs from header commdlg.h; example PRINTDLG.}
@itemdef{wxUSE_CRASHREPORT, Use wxCrashReport class.}
@itemdef{wxUSE_DATEPICKCTRL_GENERIC, Use generic wxDatePickerCtrl implementation in addition to the native one.}
@itemdef{wxUSE_DC_CACHEING, cache temporary wxDC objects.}
@itemdef{wxUSE_DIRECTDRAW, Enable use of the system include file ddraw.h.}
@itemdef{wxUSE_DDE_FOR_IPC, See wx/ipc.h file.}
@itemdef{wxUSE_ENH_METAFILE, Use wxEnhMetaFile.}
@itemdef{wxUSE_HOTKEY, Use wxWindow::RegisterHotKey() and wxWindow::UnregisterHotKey}
@itemdef{wxUSE_INKEDIT, Use InkEdit library. Related to Tablet PCs.}
@itemdef{wxUSE_MS_HTML_HELP, Use wxCHMHelpController class.}
@itemdef{wxUSE_NO_MANIFEST, Use to prevent the auto generation, under MSVC, of manifest file needed by windows XP and above.}
@itemdef{wxUSE_NORLANDER_HEADERS, Using headers whose author is Anders Norlander.}
@itemdef{wxUSE_OLE, Enables OLE helper routines.}
@itemdef{wxUSE_OLE_AUTOMATION, Enable OLE automation utilities.}
@itemdef{wxUSE_OLE_CLIPBOARD, Use OLE clipboard.}
@itemdef{wxUSE_PENWINDOWS, See src/msw/penwin.cpp file.}
@itemdef{wxUSE_POSTSCRIPT_ARCHITECTURE_IN_MSW, Use PS printing in wxMSW.}
@itemdef{wxUSE_PS_PRINTING, See src/msw/dcprint.cpp file.}
@itemdef{wxUSE_REGKEY, Use wxRegKey class.}
@itemdef{wxUSE_RICHEDIT, Enable use of riched32.dll in wxTextCtrl}
@itemdef{wxUSE_RICHEDIT2, Enable use of riched20.dll in wxTextCtrl}
@itemdef{wxUSE_VC_CRTDBG, See wx/msw/msvcrt.h file.}
@itemdef{wxUSE_UNICODE_MSLU, Use MSLU for Unicode support under Windows 9x systems.}
@itemdef{wxUSE_UXTHEME, Enable support for XP themes.}
@itemdef{wxUSE_WIN_METAFILES_ALWAYS, Use wxMetaFile even when wxUSE_ENH_METAFILE=$1$.}
@itemdef{wxUSE_WXDIB, Use wxDIB class.}
@itemdef{wxUSE_XPM_IN_MSW, See also wxUSE_XPM}
@endDefList
@section page_wxusedef_univ wxUSE preprocessor symbols used only in wxUniversal
@beginDefList
@itemdef{wxUSE_ALL_THEMES, Use all themes in wxUniversal; See wx/univ/theme.h file.}
@itemdef{wxUSE_THEME_GTK, Use GTK+ 1-like theme in wxUniversal}
@itemdef{wxUSE_THEME_METAL, Use GTK+ 2-like theme in wxUniversal}
@itemdef{wxUSE_THEME_MONO, Use simple monochrome theme in wxUniversal}
@itemdef{wxUSE_THEME_WIN32, Use Win32-like theme in wxUniversal}
@endDefList
*/

24
docs/doxygen/mainpages/constants.h Normal file
View File

@ -0,0 +1,24 @@
/////////////////////////////////////////////////////////////////////////////
// Name: constants.h
// Purpose: Constants page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_constants Constants
This chapter describes the constants defined by wxWidgets.
@li @subpage page_cppconst
@li @subpage page_keycodes
@li @subpage page_keymodifiers
@li @subpage page_languagecodes
@li @subpage page_stdevtid
@li @subpage page_stockitems
@li @subpage page_wxusedef
*/

596
docs/doxygen/mainpages/copyright.h Normal file
View File

@ -0,0 +1,596 @@
/////////////////////////////////////////////////////////////////////////////
// Name: copyright.h
// Purpose: Copyright page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_copyright Copyright notice
<center>
Copyright (c) 1992-2008 Julian Smart, Robert Roebling, Vadim Zeitlin and other
members of the wxWidgets team
Portions (c) 1996 Artificial Intelligence Applications Institute
</center>
Please also see the wxWindows license files (preamble.txt, lgpl.txt, gpl.txt,
licence.txt, licendoc.txt) for conditions of software and documentation use.
Note that we use the old name wxWindows in the license, pending
recognition of the new name by OSI.
@li @subpage page_copyright_wxlicense
@li @subpage page_copyright_gnulicense
*/
/*!
@page page_copyright_wxlicense wxWindows Library License, Version 3.1
<!--
NB: this is exact copy of docs/licence.txt file. DO NOT modify this
section, it MUST be identical to docs/licence.txt!
-->
Copyright (c) 1998-2008 Julian Smart, Robert Roebling et al
Everyone is permitted to copy and distribute verbatim copies
of this licence document, but changing it is not allowed.
<center>
WXWINDOWS LIBRARY LICENCE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
</center>
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Library General Public Licence as published by
the Free Software Foundation; either version 2 of the Licence, or (at
your option) any later version.
This library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library
General Public Licence for more details.
You should have received a copy of the GNU Library General Public Licence
along with this software, usually in a file named COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
Boston, MA 02111-1307 USA.
EXCEPTION NOTICE
1. As a special exception, the copyright holders of this library give
permission for additional uses of the text contained in this release of
the library as licenced under the wxWindows Library Licence, applying
either version 3.1 of the Licence, or (at your option) any later version of
the Licence as published by the copyright holders of version 3.1 of the
Licence document.
2. The exception is that you may use, copy, link, modify and distribute
under your own terms, binary object code versions of works based
on the Library.
3. If you copy code from files distributed under the terms of the GNU
General Public Licence or the GNU Library General Public Licence into a
copy of this library, as this licence permits, the exception does not
apply to the code that you add in this way. To avoid misleading anyone as
to the status of such modified files, you must delete this exception
notice from such code and/or adjust the licensing conditions notice
accordingly.
4. If you write modifications of your own for this library, it is your
choice whether to permit this exception to apply to your modifications.
If you do not wish that, you must delete the exception notice from such
code and/or adjust the licensing conditions notice accordingly.
*/
/*!
@page page_copyright_gnulicense GNU Library General Public License, Version 2
Copyright (C) 1991 Free Software Foundation, Inc.
675 Mass Ave, Cambridge, MA 02139, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
@section page_copyright_gnulicense_preamble Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software -- to make sure the software is free for all its users.
This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
<center>
GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
</center>
0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
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.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
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
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
c) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
d) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
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
Sections above.
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.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
<center>
NO WARRANTY
</center>
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
<center>
END OF TERMS AND CONDITIONS
</center>
@section page_copyright_gnulicense_appendix Appendix: How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
@verbatim
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
@endverbatim
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
@verbatim
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
@endverbatim
That's all there is to it!
*/

311
docs/doxygen/mainpages/devtips.h Normal file
View File

@ -0,0 +1,311 @@
/////////////////////////////////////////////////////////////////////////////
// Name: devtips.h
// Purpose: Cross-platform development page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_multiplatform Multi-platform development with wxWidgets
This chapter describes the practical details of using wxWidgets. Please
see the file install.txt for up-to-date installation instructions, and
changes.txt for differences between versions.
@li @ref page_multiplatform_includefiles
@li @ref page_multiplatform_libraries
@li @ref page_multiplatform_configuration
@li @ref page_multiplatform_makefiles
@li @ref page_multiplatform_windowsfiles
@li @ref page_multiplatform_allocatingobjects
@li @ref page_multiplatform_architecturedependency
@li @ref page_multiplatform_conditionalcompilation
@li @ref page_multiplatform_cpp
@li @ref page_multiplatform_filehandling
<hr>
@section page_multiplatform_includefiles Include files
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
source file. If you are using precompiled headers, you should include
the following section before any other includes:
@verbatim
// For compilers that support precompilation, includes "wx.h".
#include <wx/wxprec.h>
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef WX_PRECOMP
// Include your minimal set of headers here, or wx.h
#include <wx/wx.h>
#endif
... now your other include files ...
@endverbatim
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
embedded Visual C++), Borland C++, Open Watcom C++, Digital Mars C++
and newer versions of GCC.
Some compilers might need extra work from the application developer to set the
build environment up as necessary for the support.
@section page_multiplatform_libraries Libraries
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 @ref libraries_page for more information on these.
@section page_multiplatform_configuration Configuration
When using project files and makefiles directly to build wxWidgets,
options are configurable in the file
@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 @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
along with suitable makefiles. When using the RPM packages
for installing wxWidgets on Linux, a correct setup.h is shipped in the package and
this must not be changed.
@section page_multiplatform_makefiles Makefiles
On Microsoft Windows, wxWidgets has a different set of makefiles for each
compiler, because each compiler's 'make' tool is slightly different.
Popular Windows compilers that we cater for, and the corresponding makefile
extensions, include: Microsoft Visual C++ (.vc), Borland C++ (.bcc),
OpenWatcom C++ (.wat) and MinGW/Cygwin (.gcc). Makefiles are provided
for the wxWidgets library itself, samples, demos, and utilities.
On Linux, Mac and OS/2, you use the 'configure' command to
generate the necessary makefiles. You should also use this method when
building with MinGW/Cygwin on Windows.
We also provide project files for some compilers, such as
Microsoft VC++. However, we recommend using makefiles
to build the wxWidgets library itself, because makefiles
can be more powerful and less manual intervention is required.
On Windows using a compiler other than MinGW/Cygwin, you would
build the wxWidgets library from the build/msw directory
which contains the relevant makefiles.
On Windows using MinGW/Cygwin, and on Unix, MacOS X and OS/2, you invoke
'configure' (found in the top-level of the wxWidgets source hierarchy),
from within a suitable empty directory for containing makefiles, object files and
libraries.
For details on using makefiles, configure, and project files,
please see docs/xxx/install.txt in your distribution, where
xxx is the platform of interest, such as msw, gtk, x11, mac.
@section page_multiplatform_windowsfiles Windows-specific files
wxWidgets application compilation under MS Windows requires at least one
extra file: a resource file.
@subsection page_multiplatform_windowsfiles_resources Resource file
The least that must be defined in the Windows resource file (extension RC)
is the following statement:
@verbatim
#include "wx/msw/wx.rc"
@endverbatim
which includes essential internal wxWidgets definitions. The resource script
may also contain references to icons, cursors, etc., for example:
@verbatim
wxicon icon wx.ico
@endverbatim
The icon can then be referenced by name when creating a frame icon. See
the MS Windows SDK documentation.
@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 page_multiplatform_allocatingobjects Allocating and deleting wxWidgets objects
In general, classes derived from wxWindow must dynamically allocated
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 @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.
Don't create a window on the stack, because this will interfere
with delayed deletion.
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 @e delete on
array members will cause memory problems.
wxColour can be created statically: it is not automatically cleaned
up and is unlikely to be shared between other objects; it is lightweight
enough for copies to be made.
Beware of deleting objects such as a wxPen or wxBitmap if they are still in use.
Windows is particularly sensitive to this: so make sure you
make calls like wxDC::SetPen(wxNullPen) or wxDC::SelectObject(wxNullBitmap) before deleting
a drawing object that may be in use. Code that doesn't do this will probably work
fine on some platforms, and then fail under Windows.
@section page_multiplatform_architecturedependency Architecture dependency
A problem which sometimes arises from writing multi-platform programs is that
the basic C types are not defined the same on all platforms. This holds true
for both the length in bits of the standard types (such as int and long) as
well as their byte order, which might be little endian (typically
on Intel computers) or big endian (typically on some Unix workstations). wxWidgets
defines types and macros that make it easy to write architecture independent
code. The types are:
wxInt32, wxInt16, wxInt8, wxUint32, wxUint16 = wxWord, wxUint8 = wxByte
where wxInt32 stands for a 32-bit signed integer type etc. You can also check
which architecture the program is compiled on using the wxBYTE_ORDER define
which is either wxBIG_ENDIAN or wxLITTLE_ENDIAN (in the future maybe wxPDP_ENDIAN
as well).
The macros handling bit-swapping with respect to the applications endianness
are described in the @ref byteordermacros section.
@section page_multiplatform_conditionalcompilation Conditional compilation
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 @ref wxusedef
symbols listed in the file @c setup.h may be used for this purpose,
along with any user-supplied ones.
@section page_multiplatform_cpp C++ issues
The following documents some miscellaneous C++ issues.
@subsection page_multiplatform_cpp_templates Templates
wxWidgets does not use templates (except for some advanced features that
are switched off by default) since it is a notoriously unportable feature.
@subsection page_multiplatform_cpp_rtti RTTI
wxWidgets does not use C++ run-time type information since wxWidgets provides
its own run-time type information system, implemented using macros.
@subsection page_multiplatform_cpp_null Type of NULL
Some compilers (e.g. the native IRIX cc) define NULL to be 0L so that
no conversion to pointers is allowed. Because of that, all these
occurrences of NULL in the GTK+ port use an explicit conversion such
as
@code
wxWindow *my_window = (wxWindow*) NULL;
@endcode
It is recommended to adhere to this in all code using wxWidgets as
this make the code (a bit) more portable.
@subsection page_multiplatform_cpp_precompiledheaders Precompiled headers
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 @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)
to allow initial creation of the precompiled header.
However, there are several downsides to using precompiled headers. One
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 @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 @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++.
@section page_multiplatform_filehandling File handling
When building an application which may be used under different
environments, one difficulty is coping with documents which may be
moved to different directories on other machines. Saving a file which
has pointers to full pathnames is going to be inherently unportable.
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 wxStandardPaths.
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;
the exact maximum length, as well as the characters allowed in the filenames,
are OS-specific so you should try to avoid extremely long (> 255 chars) filenames
and/or filenames with non-ANSI characters.
Another thing you need to keep in mind is that all Windows operating systems
are case-insensitive, while Unix operating systems (Linux, Mac, etc) are
case-sensitive.
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 wxTextFile, wxTextInputStream, wxTextOutputStream classes help to abstract
from these differences.
Of course, there are also 3rd party utilities such as @c dos2unix and @c unix2dos
which do the EOL conversions.
See also the @ref filefunctions section of the reference
manual for the description of miscellaneous file handling functions.
*/

234
docs/doxygen/mainpages/introduction.h Normal file
View File

@ -0,0 +1,234 @@
/////////////////////////////////////////////////////////////////////////////
// Name: introduction.h
// Purpose: Introduction page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_introduction Introduction
@li @ref page_introduction_whatis
@li @ref page_introduction_why
@li @ref page_introduction_requirements
@li @ref page_introduction_where
@li @ref page_introduction_acknowledgements
<hr>
@section page_introduction_whatis What is wxWidgets?
wxWidgets is a C++ framework providing GUI (Graphical User
Interface) and other facilities on more than one platform. Version 2 and higher
currently support all desktop versions of MS Windows, Unix with GTK+ 1.x or 2.x,
Unix with Motif, Unix with just X11, Unix with DirectFB, Mac OS X, OS/2.
wxWidgets was originally developed at the Artificial Intelligence
Applications Institute, University of Edinburgh, for internal use,
and was first made publicly available in 1992.
Version 2 is a vastly improved version written and maintained by
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 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
variants, unless otherwise stated. All trademarks are acknowledged.
@section page_introduction_why Why another cross-platform development tool?
wxWidgets was developed to provide a cheap and flexible way to maximize
investment in GUI application development. While a number of commercial
class libraries already existed for cross-platform development,
none met all of the following criteria:
@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
features, flexibility, documentation and the well-established
development team that wxWidgets has.
As open source software, wxWidgets has benefited from comments,
ideas, bug fixes, enhancements and the sheer enthusiasm of
users. This gives wxWidgets a certain advantage over its
commercial competitors (and over free libraries without an
independent development team), plus a robustness against the
transience of one individual or company. This openness and
availability of source code is especially important when the
future of thousands of lines of application code may depend upon
the longevity of the underlying class library.
Version 2 goes much further than previous versions in terms of
generality and features, allowing applications to be produced
that are often indistinguishable from those produced using
single-platform toolkits such as Motif, GTK+ and MFC.
The importance of using a platform-independent class library
cannot be overstated, since GUI application development is very
time-consuming, and sustained popularity of particular GUIs
cannot be guaranteed. Code can very quickly become obsolete if
it addresses the wrong platform or audience. wxWidgets helps to
insulate the programmer from these winds of change. Although
wxWidgets may not be suitable for every application (such as an
OLE-intensive program), it provides access to most of the
functionality a GUI program normally requires, plus many extras
such as network programming, PostScript output, and HTML
rendering; and it can of course be extended as needs dictate.
As a bonus, it provides a far cleaner and easier programming
interface than the native APIs. Programmers may find it
worthwhile to use wxWidgets even if they are developing on only
one platform.
It is impossible to sum up the functionality of wxWidgets in a few paragraphs, but
here are some of the benefits:
@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 page_introduction_requirements wxWidgets requirements
To make use of wxWidgets, you currently need one of the following setups.
(a) MS-Windows:
@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:
@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:
@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 page_introduction_where Availability and location of wxWidgets
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 page_introduction_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:
@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.
Apologies for any unintentional omissions from this alphabetic list:
Yiorgos Adamopoulos, Jamshid Afshar, Alejandro Aguilar-Sierra, AIAI,
Patrick Albert, Karsten Ballueder, Mattia Barbon, Michael Bedward,
Kai Bendorf, Yura Bidus, Keith Gary Boyce, Chris Breeze, Pete Britton,
Ian Brown, C. Buckley, Marco Cavallini, Dmitri Chubraev, Robin Corbet, Cecil Coupe,
Andrew Davison, Gilles Depeyrot, Neil Dudman, Hermann Dunkel, Jos van Eijndhoven,
Tom Felici, Thomas Fettig, Matthew Flatt, Pasquale Foggia, Josep Fortiana, Todd Fries,
Dominic Gallagher, Guillermo Rodriguez Garcia, Wolfram Gloger, Norbert Grotz,
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&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&auml;, George Tasker,
Arthur Tetzlaff-Deas, Jonathan Tonberg, Jyrki Tuomi, Janos Vegh, Andrea Venturoli,
David Webster, Otto Wyss, Xiaokun Zhu, Edward Zimmermann.
Many thanks also to AIAI for being willing to release the original version of
wxWidgets into the public domain, and to our patient partners.
`Graphplace', the basis for the wxGraphLayout library, is copyright Dr. Jos
T.J. van Eijndhoven of Eindhoven University of Technology. The code has
been used in wxGraphLayout (not in wxWidgets anymore) with his permission.
We also acknowledge the author of XFIG, the excellent Unix drawing tool,
from the source of which we have borrowed some spline drawing code.
His copyright is included below.
<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
copyright notice and this permission notice appear in supporting
documentation, and that the name of M.I.T. not be used in advertising or
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.
</em>
*/

156
docs/doxygen/mainpages/libs.h Normal file
View File

@ -0,0 +1,156 @@
/////////////////////////////////////////////////////////////////////////////
// Name: libs.h
// Purpose: Libraries page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_libraries Libraries list
wxWidgets can be built either as a single large
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:
@image html libs.gif
Please note that arrows indicate the "depends from" relation and that
all blue boxes depend from @ref wxbase library (i.e. they are non-GUI libraries),
and all green boxes depend from @ref wxcore library (i.e. they are GUI libraries).
<!--
IMPORTANT: the @sections below don't have the page_libraries_ prefix because
all API pages link to them and using that prefix all times would
make the
-->
@section page_libraries_wxbase wxBase
Every wxWidgets application must link against this library. It contains
mandatory classes that any wxWidgets code depends on (e.g. wxString) and
portability classes that abstract differences between platforms.
@ref wxbase can be used to develop console mode applications, it does not require
any GUI libraries or running X Window System on Unix.
@section page_libraries_wxcore wxCore
Basic GUI classes such as GDI classes or controls are in this library. All
wxWidgets GUI applications must link against this library, only console mode
applications don't.
Requires @ref wxbase.
@section wxaui wxAui
This contains the Advanced User Interface docking library.
Requires @ref wxadv, @ref wxhtml, @ref wxxml, @ref wxcore, @ref wxbase.
@section wxnet wxNet
Classes for network access:
@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 @ref wxbase.
@section wxrichtext wxRichText
This contains generic rich text control functionality.
Requires @ref wxadv, @ref wxhtml, @ref wxxml, @ref wxcore, @ref wxbase.
@section wxxml wxXML
This library contains simple classes for parsing XML documents.
Requires @ref wxbase.
@section wxadv wxAdvanced
Advanced or rarely used GUI classes:
@li wxCalendarCtrl
@li wxGrid classes
@li wxJoystick
@li wxLayoutAlgorithm
@li wxSplashScreen
@li wxTaskBarIcon
@li wxSound
@li wxWizard
@li wxSashLayoutWindow
@li wxSashWindow
@li ...others
Requires @ref wxcore and @ref wxbase.
@section wxmedia wxMedia
Miscellaneous classes related to multimedia. Currently this library only
contains wxMediaCtrl but more classes will be added in
the future.
Requires @ref wxcore and @ref wxbase.
@section wxgl wxGL
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.
Requires @ref wxcore and @ref wxbase.
@section wxhtml wxHTML
Simple HTML renderer and other @ref html_overview are contained in this library,
as well as wxHtmlHelpController, wxBestHelpController and wxHtmlListBox.
Requires @ref wxcore and @ref wxbase.
@section wxqa wxQA
This is the library containing extra classes for quality assurance. Currently
it only contains wxDebugReport and related classes,
but more will be added to it in the future.
Requires @ref wxxml, @ref wxcore, @ref wxbase.
@section wxxrc wxXRC
This library contains wxXmlResource class that
provides access to XML resource files in XRC format.
Requires @ref wxadv, @ref wxhtml, @ref wxxml, @ref wxcore, @ref wxbase.
@section wxstc wxSTC
STC (Styled Text Control) is a wrapper around Scintilla, a syntax-highlighting text editor.
See http://www.scintilla.org for more info about Scintilla.
Requires @ref wxcore, @ref wxbase.
*/

33
docs/doxygen/mainpages/manual.h Normal file
View File

@ -0,0 +1,33 @@
/////////////////////////////////////////////////////////////////////////////
// Name: main.h
// Purpose: Main page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@mainpage wxWidgets 2.9.0: A portable C++ and Python GUI toolkit
@author Julian Smart, Robert Roebling, Vadim Zeitlin, Robin Dunn, et al
@date February, 2008
@image html wx.png
@section Contents
@li @subpage page_copyright
@li @subpage page_introduction
@li @subpage page_multiplatform
@li @subpage page_utils
@li @subpage page_strategies
@li @subpage page_libraries
@li @subpage page_constants
@li @subpage page_categories
@li @subpage page_topics
@li @subpage page_platdetails
<!-- @li Alphabetical class reference
@li Functions and macros -->
*/

593
docs/doxygen/mainpages/platdetails.h Normal file
View File

@ -0,0 +1,593 @@
/////////////////////////////////////////////////////////////////////////////
// Name: platdetails.h
// Purpose: Platform details page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_platdetails Platform details
wxWidgets defines a common API across platforms, but uses the native graphical
user interface (GUI) on each platform, so your program will take on the native
look and feel that users are familiar with. Unfortunately native toolkits and
hardware do not always support the functionality that the wxWidgets API
requires. This chapter collects notes about differences among supported platforms
and ports.
@li @ref page_platdetails_wxgtkport
@li @ref page_platdetails_wxmacport
@li @ref page_platdetails_wxos2port
@li @ref page_platdetails_wxmglport
@li @ref page_platdetails_wxx11port
@li @ref page_platdetails_wxmswport
@li @ref page_platdetails_nativedocs
<hr>
@section page_platdetails_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 page_platdetails_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 page_platdetails_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 page_platdetails_wxos2port wxOS2 port
wxOS2 is a port of wxWidgets for the IBM OS/2 platform.
It is currently under construction.
@section page_platdetails_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 page_platdetails_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 page_platdetails_wxmswport_themedborders 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 page_platdetails_wxmswport_themedborders_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 page_platdetails_wxmswport_wince 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 page_platdetails_wxmswport_wince_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 page_platdetails_wxmswport_wince_sdk 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 page_platdetails_wxmswport_wince_sizing 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 page_platdetails_wxmswport_wince_toplevel 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 page_platdetails_wxmswport_wince_hibernation 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 page_platdetails_wxmswport_wince_hwbutt 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 page_platdetails_wxmswport_wince_dialogs 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 page_platdetails_wxmswport_wince_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 page_platdetails_wxmswport_wince_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 page_platdetails_wxmswport_wince_closing 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 page_platdetails_wxmswport_wince_ctx 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 page_platdetails_wxmswport_wince_ctrl 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 page_platdetails_wxmswport_wince_help 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 page_platdetails_wxmswport_wince_install 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 page_platdetails_wxmswport_wince_filedlg 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 page_platdetails_wxmswport_wince_evc 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 page_platdetails_wxmswport_wince_issues 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 page_platdetails_nativedocs Documentation for the native toolkits
It's sometimes useful to interface directly with the underlying toolkit
used by wxWidgets to e.g. use toolkit-specific features.
In such case (or when you want to e.g. write a port-specific patch) it can be
necessary to use the underlying toolkit API directly:
@li wxMSW port uses win32 API: see MSDN docs at http://msdn2.microsoft.com/en-us/library/ms649779.aspx
@li wxGTK port uses GTK+: see GTK+ 2.x docs at http://developer.gnome.org/doc/API/2.0/gtk/index.html
*/

125
docs/doxygen/mainpages/strategies.h Normal file
View File

@ -0,0 +1,125 @@
/////////////////////////////////////////////////////////////////////////////
// Name: strategies.h
// Purpose: Strategies page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_strategies 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 page_strategies_reducingerr
@li @ref page_strategies_portability
@li @ref page_strategies_debug
<hr>
@section page_strategies_reducingerr Strategies for reducing programming errors
@subsection page_strategies_reducingerr_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 wxASSERT for more info.
@subsection page_strategies_reducingerr_usewxstring Use wxString in preference to character arrays
Using 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 @c 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 page_strategies_portability Strategies for portability
@subsection page_strategies_portability_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 @ref sizer_overview instead.
@subsection page_strategies_portability_useresources Use wxWidgets resource files
Use .xrc (wxWidgets resource files) where possible, because they can be easily changed
independently of source code. See the @ref xrc_overview for more info.
@section page_strategies_debug Strategies for debugging
@subsection page_strategies_debug_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 page_strategies_debug_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 page_strategies_debug_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 page_strategies_debug_uselogging Use logging functions
There is a variety of logging functions that you can use in your program:
see @ref 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 page_strategies_debug_usedebuggingfacilities Use the wxWidgets debugging facilities
You can use 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 @ref 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 @ref debugging_overview for further information.
*/

107
docs/doxygen/mainpages/topics.h Normal file
View File

@ -0,0 +1,107 @@
/////////////////////////////////////////////////////////////////////////////
// Name: topics.h
// Purpose: Topic overviews page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_topics Topic overviews
This chapter contains a selection of topic overviews.
The following are a basic categorization of them:
@li @ref page_topics_starting
@li @ref page_topics_programming
@li @ref page_topics_nongui
@li @ref page_topics_drawing
@li @ref page_topics_gui
@li @ref page_topics_indivctrl
<hr>
@section page_topics_starting Starting with wxWidgets
@li @subpage referencenotes_overview
@li @subpage roughguide_overview
@li @subpage helloworld_overview
@li @subpage samples_overview
@li @subpage python_overview
@section page_topics_programming Programming with wxWidgets
@li @subpage backwardcompatibility_overview
@li @subpage runtimeclass_overview
@li @subpage trefcount_overview
@li @subpage app_overview
@li @subpage unicode_overview
@li @subpage mbconvclasses_overview
@li @subpage internationalization_overview
@li @subpage nonenglish_overview
@li @subpage debugging_overview
@li @subpage log_overview
@li @subpage eventhandling_overview
@li @subpage exceptions_overview
@li @subpage windowstyles_overview
@li @subpage windowdeletion_overview
@li @subpage windowids_overview
@li @subpage envvars_overview
@section page_topics_nongui Overviews of non-GUI classes
@li @subpage string_overview
@li @subpage bufferclasses_overview
@li @subpage datetime_overview
@li @subpage container_overview
@li @subpage file_overview
@li @subpage stream_overview
@li @subpage thread_overview
@li @subpage config_overview
@li @subpage fs_overview
@li @subpage resyn_overview
@li @subpage arc_overview
@li @subpage ipc_overview
@section page_topics_drawing Drawing related classes
@li @subpage dc_overview
@li @subpage bitmap_overview
@li @subpage font_overview
@li @subpage fontencoding_overview
@li @subpage printing_overview
@li @subpage unixprinting_overview
@section page_topics_gui Overviews of GUI classes
@li @subpage sizer_overview
@li @subpage xrc_overview
@li @subpage windowsizing_overview
@li @subpage scrolling_overview
@li @subpage dialog_overview
@li @subpage validator_overview
@li @subpage dataobject_overview
@li @subpage dnd_overview
@li @subpage constraints_overview
@section page_topics_indivctrl Overviews of individual controls
@li @subpage html_overview
@li @subpage richtextctrl_overview
@li @subpage aui_overview
@li @subpage commondialogs_overview
@li @subpage toolbar_overview
@li @subpage grid_overview
@li @subpage treectrl_overview
@li @subpage listctrl_overview
@li @subpage splitterwindow_overview
@li @subpage imagelist_overview
@li @subpage bookctrl_overview
@li @subpage tips_overview
@li @subpage docview_overview
*/

610
docs/doxygen/mainpages/utilities.h Normal file
View File

@ -0,0 +1,610 @@
/////////////////////////////////////////////////////////////////////////////
// Name: utilities.h
// Purpose: Utilities page of the Doxygen manual
// Author: wxWidgets team
// RCS-ID: $Id$
// Licence: wxWindows license
/////////////////////////////////////////////////////////////////////////////
/*!
@page page_utils Utilities and samples supplied with wxWidgets
@li @ref page_utils_utils
@li @ref page_utils_samples
<hr>
@section page_utils_utils Utilities
In addition to the @ref libraries_page, some
additional utilities are supplied in the @c utils hierarchy.
For other user-contributed packages, please see the Contributions page
on the wxWidgets Web site http://www.wxwidgets.org.
@subsection page_utils_utils_helpview 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 @ref html_overview for more details.
You can find it in @c samples/html/helpview.
@subsection page_utils_utils_tex2rtf Tex2RTF
Supplied with wxWidgets is a utility called Tex2RTF for
converting @e LaTeX manuals HTML, MS HTML Help, wxHTML Help, RTF, and Windows
Help RTF formats. Tex2RTF was used for the wxWidgets manuals and can be used
independently by authors wishing to create on-line and printed manuals from the
same @e LaTeX source. Please see the separate documentation for Tex2RTF.
You can find it under @c utils/tex2rtf.
@subsection page_utils_utils_helpgen 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 @c utils/HelpGen.
@subsection page_utils_utils_emulator 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 @c utils/emulator.
@section page_utils_samples Samples
Probably the best way to learn wxWidgets is by reading the source of some 50+
samples provided with it. Many aspects of wxWidgets programming can be learnt
from them, but sometimes it is not simple to just choose the right sample to
look at. This overview aims at describing what each sample does/demonstrates to
make it easier to find the relevant one if a simple grep through all sources
didn't help. They also provide some notes about using the samples and what
features of wxWidgets are they supposed to test.
There are currently more than 50 different samples as part of wxWidgets and
this list is not complete. You should start your tour of wxWidgets with the
minimal sample which is the wxWidgets version of
"Hello, world!". It shows the basic structure of wxWidgets program and is the
most commented sample of all - looking at its source code is recommended.
The next most useful samples are probably widgets
and controls which show many of wxWidgets native and
generic controls, such as buttons, listboxes, checkboxes, comboboxes etc.
Other, more complicated controls, have their own samples. In this category you
may find the following samples showing the corresponding controls:
@li wxCalendarCtrl: @ref page_utils_samples_calendar
@li wxListCtrl: @ref page_utils_samples_listctrl
@li wxTreeCtrl: @ref page_utils_samples_treectrl
@li wxGrid: @ref page_utils_samples_grid
Finally, it might be helpful to do a search in the entire sample directory if
you can't find the sample showing the control you are interested in by
name. Most classes contained in wxWidgets occur in at least one of the samples.
@subsection page_utils_samples_minimal Minimal sample
The minimal sample is what most people will know under the term Hello World,
i.e. a minimal program that doesn't demonstrate anything apart from what is
needed to write a program that will display a "hello" dialog. This is usually
a good starting point for learning how to use wxWidgets.
@subsection page_utils_samples_animate Animate sample
The @c animate sample shows how you can use wxAnimationCtrl
control and shows concept of a platform-dependent animation encapsulated
in wxAnimation.
@subsection page_utils_samples_artprovider Art provider sample
The @c artprov sample shows how you can customize the look of standard
wxWidgets dialogs by replacing default bitmaps/icons with your own versions.
It also shows how you can use wxArtProvider to
get stock bitmaps for use in your application.
@subsection page_utils_samples_calendar Calendar sample
This font shows the calendar control in action. It
shows how to configure the control (see the different options in the calendar
menu) and also how to process the notifications from it.
@subsection page_utils_samples_config Config sample
This sample demonstrates the wxConfig classes in a platform
independent way, i.e. it uses text based files to store a given configuration under
Unix and uses the Registry under Windows.
See wxConfig overview for the descriptions of all
features of this class.
@subsection page_utils_samples_controls Controls sample
The controls sample is the main test program for most simple controls used in
wxWidgets. The sample tests their basic functionality, events, placement,
modification in terms of colour and font as well as the possibility to change
the controls programmatically, such as adding an item to a list box etc. Apart
from that, the sample uses a wxNotebook and tests most
features of this special control (using bitmap in the tabs, using
wxSizer instances and wxLayoutConstraints within notebook pages, advancing pages
programmatically and vetoing a page change by intercepting the wxNotebookEvent.
The various controls tested are listed here:
@li wxButton
@li wxBitmapButton
@li wxCheckBox
@li wxChoice
@li wxComboBox
@li wxGauge
@li wxStaticBox
@li wxListBox
@li wxSpinCtrl
@li wxSpinButton
@li wxStaticText
@li wxStaticBitmap
@li wxRadioBox
@li wxRadioButton
@li wxSlider
@subsection page_utils_samples_debugrpt DebugRpt sample
This sample shows how to use wxDebugReport class to
generate a debug report in case of a program crash or otherwise. On start up,
it proposes to either crash itself (by dereferencing a NULL pointer) or
generate debug report without doing it. Next it initializes the debug report
with standard information adding a custom file to it (just a timestamp) and
allows to view the information gathered using
wxDebugReportPreview.
For the report processing part of the sample to work you should make available
a Web server accepting form uploads, otherwise
wxDebugReportUpload will report an error.
@subsection page_utils_samples_dialogs Dialogs sample
This sample shows how to use the common dialogs available from wxWidgets. These
dialogs are described in detail in the Common dialogs overview.
@subsection page_utils_samples_dialup Dialup sample
This sample shows the wxDialUpManager
class. In the status bar, it displays the information gathered through its
interface: in particular, the current connection status (online or offline) and
whether the connection is permanent (in which case a string `LAN' appears in
the third status bar field - but note that you may be on a LAN not
connected to the Internet, in which case you will not see this) or not.
Using the menu entries, you may also dial or hang up the line if you have a
modem attached and (this only makes sense for Windows) list the available
connections.
@subsection page_utils_samples_dnd DnD sample
This sample shows both clipboard and drag and drop in action. It is quite non
trivial and may be safely used as a basis for implementing the clipboard and
drag and drop operations in a real-life program.
When you run the sample, its screen is split in several parts. On the top,
there are two listboxes which show the standard derivations of
wxDropTarget:
wxTextDropTarget and
wxFileDropTarget.
The middle of the sample window is taken by the log window which shows what is
going on (of course, this only works in debug builds) and may be helpful to see
the sequence of steps of data transfer.
Finally, the last part is used for dragging text from it to either one of the
listboxes (only one will accept it) or another application. The last
functionality available from the main frame is to paste a bitmap from the
clipboard (or, in the case of the Windows version, also a metafile) - it will be
shown in a new frame.
So far, everything we mentioned was implemented with minimal amount of code
using standard wxWidgets classes. The more advanced features are demonstrated
if you create a shape frame from the main frame menu. A shape is a geometric
object which has a position, size and color. It models some
application-specific data in this sample. A shape object supports its own
private wxDataFormat which means that you may cut and
paste it or drag and drop (between one and the same or different shapes) from
one sample instance to another (or the same). However, chances are that no
other program supports this format and so shapes can also be rendered as
bitmaps which allows them to be pasted/dropped in many other applications
(and, under Windows, also as metafiles which are supported by most of Windows
programs as well - try Write/Wordpad, for example).
Take a look at DnDShapeDataObject class to see how you may use
wxDataObject to achieve this.
@subsection page_utils_samples_event Event sample
The event sample demonstrates various features of the wxWidgets events. It
shows using dynamic events and connecting/disconnecting the event handlers
during run time and also using
PushEventHandler() and
PopEventHandler().
@subsection page_utils_samples_except Except(ions) sample
This very simple sample shows how to use C++ exceptions in wxWidgets programs,
i.e. where to catch the exception which may be thrown by the program code. It
doesn't do anything very exciting by itself, you need to study its code to
understand what goes on.
You need to build the library with @c wxUSE_EXCEPTIONS being set to @c 1
and compile your code with C++ exceptions support to be able to build this
sample.
@subsection page_utils_samples_exec Exec sample
The exec sample demonstrates the wxExecute and
wxShell functions. Both of them are used to execute the
external programs and the sample shows how to do this synchronously (waiting
until the program terminates) or asynchronously (notification will come later).
It also shows how to capture the output of the child process in both
synchronous and asynchronous cases and how to kill the processes with
wxProcess::Kill and test for their existence with
wxProcess::Exists.
@subsection page_utils_samples_font Font sample
The font sample demonstrates wxFont,
wxFontEnumerator and
wxFontMapper classes. It allows you to see the fonts
available (to wxWidgets) on the computer and shows all characters of the
chosen font as well.
@subsection page_utils_samples_grid Grid sample
TODO.
@subsection page_utils_samples_html HTML samples
Eight HTML samples (you can find them in directory @c samples/html)
cover all features of the HTML sub-library.
@li @b Test demonstrates how to create wxHtmlWindow
and also shows most supported HTML tags.
@li @b Widget shows how you can embed ordinary controls or windows within an
HTML page. It also nicely explains how to write new tag handlers and extend
the library to work with unsupported tags.
@li @b About may give you an idea how to write good-looking About boxes.
@li @b Zip demonstrates use of virtual file systems in wxHTML. The zip archives
handler (ships with wxWidgets) allows you to access HTML pages stored
in a compressed archive as if they were ordinary files.
@li @b Virtual is yet another virtual file systems demo. This one generates pages at run-time.
You may find it useful if you need to display some reports in your application.
@li @b Printing explains use of wxHtmlEasyPrinting
class which serves as as-simple-as-possible interface for printing HTML
documents without much work. In fact, only few function calls are sufficient.
@li @b Help and @b Helpview are variations on displaying HTML help
(compatible with MS HTML Help Workshop). @e Help shows how to embed
wxHtmlHelpController in your application
while @e Helpview is a simple tool that only pops up the help window and
displays help books given at command line.
@subsection page_utils_samples_image Image sample
The image sample demonstrates use of the wxImage class
and shows how to download images in a variety of formats, currently PNG, GIF,
TIFF, JPEG, BMP, PNM and PCX. The top of the sample shows two rectangles, one
of which is drawn directly in the window, the other one is drawn into a
wxBitmap, converted to a wxImage, saved as a PNG image
and then reloaded from the PNG file again so that conversions between wxImage
and wxBitmap as well as loading and saving PNG files are tested.
At the bottom of the main frame there is a test for using a monochrome bitmap by
drawing into a wxMemoryDC. The bitmap is then drawn
specifying the foreground and background colours with
wxDC::SetTextForeground and
wxDC::SetTextBackground (on the left). The
bitmap is then converted to a wxImage and the foreground colour (black) is
replaced with red using wxImage::Replace.
This sample also contains the code for testing the image rotation and resizing
and using raw bitmap access, see the corresponding menu commands.
@subsection page_utils_samples_internat Internat(ionalization) sample
The not very clearly named internat sample demonstrates the wxWidgets
internationalization (i18n for short from now on) features. To be more
precise, it only shows localization support, i.e. support for translating the
program messages into another language while true i18n would also involve
changing the other aspects of the programs behaviour.
More information about this sample can be found in the @c readme.txt file in
its directory. Please see also i18n overview.
@subsection page_utils_samples_layout Layout sample
The layout sample demonstrates the two different layout systems offered
by wxWidgets. When starting the program, you will see a frame with some
controls and some graphics. The controls will change their size whenever
you resize the entire frame and the exact behaviour of the size changes
is determined using the wxLayoutConstraints
class. See also the overview and the
wxIndividualLayoutConstraint
class for further information.
The menu in this sample offers two more tests, one showing how to use
a wxBoxSizer in a simple dialog and the other one
showing how to use sizers in connection with a wxNotebook
class. See also wxSizer.
@subsection page_utils_samples_listctrl Listctrl sample
This sample shows the wxListCtrl control. Different modes
supported by the control (list, icons, small icons, report) may be chosen from
the menu.
The sample also provides some timings for adding/deleting/sorting a lot of
(several thousands) items into the control.
@subsection page_utils_samples_mediaplayer Mediaplayer sample
This sample demonstrates how to use all the features of
wxMediaCtrl and play various types of sound, video,
and other files.
It replaces the old dynamic sample.
@subsection page_utils_samples_notebook Notebook sample
This samples shows wxBookCtrl family of controls.
Although initially it was written to demonstrate wxNotebook
only, it can now be also used to see wxListbook,
wxChoicebook and wxTreebook in action.
Test each of the controls, their orientation, images and pages using
commands through menu.
@subsection page_utils_samples_render Render sample
This sample shows how to replace the default wxWidgets
renderer and also how to write a shared library
(DLL) implementing a renderer and load and unload it during the run-time.
@subsection page_utils_samples_scrollsub Scroll subwindow sample
This sample demonstrates use of the wxScrolledWindow
class including placing subwindows into it and drawing simple graphics. It uses the
SetTargetWindow method and thus the effect
of scrolling does not show in the scrolled window itself, but in one of its subwindows.
Additionally, this samples demonstrates how to optimize drawing operations in wxWidgets,
in particular using the wxWindow::IsExposed method with
the aim to prevent unnecessary drawing in the window and thus reducing or removing
flicker on screen.
@subsection page_utils_samples_sockets Sockets sample
The sockets sample demonstrates how to use the communication facilities
provided by wxSocket. There are two different
applications in this sample: a server, which is implemented using a
wxSocketServer object, and a client, which
is implemented as a wxSocketClient.
The server binds to the local address, using TCP port number 3000,
sets up an event handler to be notified of incoming connection requests
(@b wxSOCKET_CONNECTION events), and sits there, waiting for clients
(@e listening, in socket parlance). For each accepted connection,
a new wxSocketBase object is created. These
socket objects are independent from the server that created them, so
they set up their own event handler, and then request to be notified
of @b wxSOCKET_INPUT (incoming data) or @b wxSOCKET_LOST
(connection closed at the remote end) events. In the sample, the event
handler is the same for all connections; to find out which socket the
event is addressed to, the GetSocket function
is used.
Although it might take some time to get used to the event-oriented
system upon which wxSocket is built, the benefits are many. See, for
example, that the server application, while being single-threaded
(and of course without using fork() or ugly select() loops) can handle
an arbitrary number of connections.
The client starts up unconnected, so you can use the Connect... option
to specify the address of the server you are going to connect to (the
TCP port number is hard-coded as 3000). Once connected, a number of
tests are possible. Currently, three tests are implemented. They show
how to use the basic IO calls in wxSocketBase,
such as wxSocketBase::Read, wxSocketBase::Write,
wxSocketBase::ReadMsg and wxSocketBase::WriteMsg,
and how to set up the correct IO flags depending on what you are going to
do. See the comments in the code for more information. Note that because
both clients and connection objects in the server set up an event handler
to catch @b wxSOCKET_LOST events, each one is immediately notified
if the other end closes the connection.
There is also a URL test which shows how to use
the wxURL class to fetch data from a given URL.
The sockets sample is work in progress. Some things to do:
@li More tests for basic socket functionality.
@li More tests for protocol classes (wxProtocol and its descendants).
@li Tests for the recently added (and still in alpha stage) datagram sockets.
@li New samples which actually do something useful (suggestions accepted).
@subsection page_utils_samples_sound Sound sample
The @c sound sample shows how to use wxSound for simple
audio output (e.g. notifications).
@subsection page_utils_samples_statbar Statbar sample
This sample shows how to create and use wxStatusBar. Although most of the
samples have a statusbar, they usually only create a default one and only
do it once.
Here you can see how to recreate the statusbar (with possibly different number
of fields) and how to use it to show icons/bitmaps and/or put arbitrary
controls into it.
@subsection page_utils_samples_taborder Tab order sample
This sample allows to test keyboard navigation (mostly done using the
@c TAB key, hence the sample name) between different controls.
It shows the use of wxWindow::MoveBeforeInTabOrder() and
MoveAfterInTabOrder() methods to change
the default order of the windows in the navigation chain and of
wxWindow::Navigate() for moving focus along this
chain.
@subsection page_utils_samples_text Text sample
This sample demonstrates four features: firstly the use and many variants of
the wxTextCtrl class (single line, multi line, read only,
password, ignoring TAB, ignoring ENTER).
Secondly it shows how to intercept a wxKeyEvent in both
the raw form using the @c EVT_KEY_UP and @c EVT_KEY_DOWN macros and the
higher level from using the @c EVT_CHAR macro. All characters will be logged
in a log window at the bottom of the main window. By pressing some of the function
keys, you can test some actions in the text ctrl as well as get statistics on the
text ctrls, which is useful for testing if these statistics actually are correct.
Thirdly, on platforms which support it, the sample will offer to copy text to the
wxClipboard and to paste text from it. The GTK version will
use the so called PRIMARY SELECTION, which is the pseudo clipboard under X and
best known from pasting text to the XTerm program.
Last not least: some of the text controls have tooltips and the sample also shows
how tooltips can be centrally disabled and their latency controlled.
@subsection page_utils_samples_thread Thread sample
This sample demonstrates use of threads in connection with GUI programs.
There are two fundamentally different ways to use threads in GUI programs and
either way has to take care of the fact that the GUI library itself usually
is not multi-threading safe, i.e. that it might crash if two threads try to
access the GUI class simultaneously. One way to prevent that is have a normal
GUI program in the main thread and some worker threads which work in the
background. In order to make communication between the main thread and the
worker threads possible, wxWidgets offers the wxPostEvent
function and this sample makes use of this function.
The other way to use a so called Mutex (such as those offered in the wxMutex
class) that prevent threads from accessing the GUI classes as long as any other
thread accesses them. For this, wxWidgets has the wxMutexGuiEnter
and wxMutexGuiLeave functions, both of which are
used and tested in the sample as well.
See also @ref thread_overview and wxThread.
@subsection page_utils_samples_toolbar Toolbar sample
The toolbar sample shows the wxToolBar class in action.
The following things are demonstrated:
@li Creating the toolbar using wxToolBar::AddTool and wxToolBar::AddControl: see
MyApp::InitToolbar in the sample.
@li Using @c EVT_UPDATE_UI handler for automatically enabling/disabling
toolbar buttons without having to explicitly call EnableTool. This is done
in MyFrame::OnUpdateCopyAndCut.
@li Using wxToolBar::DeleteTool and wxToolBar::InsertTool to dynamically update the
toolbar.
Some buttons in the main toolbar are check buttons, i.e. they stay checked when
pressed. On the platforms which support it, the sample also adds a combobox
to the toolbar showing how you can use arbitrary controls and not only buttons
in it.
If you toggle another toolbar in the sample (using @c Ctrl-A) you will also
see the radio toolbar buttons in action: the first three buttons form a radio
group, i.e. checking any of them automatically unchecks the previously
checked one.
@subsection page_utils_samples_treectrl Treectrl sample
This sample demonstrates using the wxTreeCtrl class. Here
you may see how to process various notification messages sent by this control
and also when they occur (by looking at the messages in the text control in
the bottom part of the frame).
Adding, inserting and deleting items and branches from the tree as well as
sorting (in default alphabetical order as well as in custom one) is
demonstrated here as well - try the corresponding menu entries.
@subsection page_utils_samples_widgets Widgets sample
The widgets sample is the main presentation program for most simple and advanced
native controls and complex generic widgets provided by wxWidgets.
The sample tests their basic functionality, events, placement, modification
in terms of colour and font as well as the possibility to change
the controls programmatically, such as adding an item to a list box etc.
All widgets are categorized for easy browsing.
@subsection page_utils_samples_wizard Wizard sample
This sample shows the so-called wizard dialog (implemented using
wxWizard and related classes). It shows almost all
features supported:
@li Using bitmaps with the wizard and changing them depending on the page
shown (notice that wxValidationPage in the sample has a different image from
the other ones)
@li Using TransferDataFromWindow
to verify that the data entered is correct before passing to the next page
(done in wxValidationPage which forces the user to check a checkbox before
continuing).
@li Using more elaborated techniques to allow returning to the previous
page, but not continuing to the next one or vice versa (in wxRadioboxPage)
@li This (wxRadioboxPage) page also shows how the page may process the
@e Cancel button itself instead of relying on the wizard parent to do it.
@li Normally, the order of the pages in the wizard is known at compile-time,
but sometimes it depends on the user choices: wxCheckboxPage shows how to
dynamically decide which page to display next (see also
wxWizardPage)
*/

7
docs/doxygen/regen.sh
View File

@ -16,4 +16,9 @@ cp wxwidgets.css out/html
currpath=`pwd`/
interfacepath=`cd ../../interface && pwd`/
cat doxygen.log | sed -e "s|$currpath||g" -e "s|$interfacepath||g" >temp
mv temp doxygen.log
mv temp doxygen.log
# filter out the following warning which we don't care about
cat doxygen.log | grep -v ".*supplied.*as.*the.*argument.*is.*not.*an.*input.*file.*" >temp
mv temp doxygen.log